@six-group/ui-library-angular 0.0.0-insider.db2b416 → 0.0.0-insider.dd1cb95

package/fesm2022/six-group-ui-library-angular.mjs

@@ -0,0 +1,3463 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, Output, ChangeDetectionStrategy, Component, Injectable, InjectionToken, inject, HostListener, Directive, Input, Optional, HostBinding, ContentChildren, provideAppInitializer, NgModule, NgZone } from '@angular/core';
+import { __decorate } from 'tslib';
+import { fromEvent } from 'rxjs';
+import { defineCustomElements } from '@six-group/ui-library/loader';
+import * as i1 from '@angular/forms';
+import { Validators, NgControl, NG_VALUE_ACCESSOR, FormControl, FormGroup, FormArray, NG_VALIDATORS } from '@angular/forms';
+import { getErrorMessage, getLanguage, showAlert } from '@six-group/ui-library';
+import * as i1$1 from '@angular/common';
+import * as i2 from '@angular/router';
+import { RouterLinkActive } from '@angular/router';
+
+/* eslint-disable */
+/* tslint:disable */
+const proxyInputs = (Cmp, inputs) => {
+    const Prototype = Cmp.prototype;
+    inputs.forEach((item) => {
+        Object.defineProperty(Prototype, item, {
+            get() {
+                return this.el[item];
+            },
+            set(val) {
+                this.z.runOutsideAngular(() => (this.el[item] = val));
+            },
+            /**
+             * In the event that proxyInputs is called
+             * multiple times re-defining these inputs
+             * will cause an error to be thrown. As a result
+             * we set configurable: true to indicate these
+             * properties can be changed.
+             */
+            configurable: true,
+        });
+    });
+};
+const proxyMethods = (Cmp, methods) => {
+    const Prototype = Cmp.prototype;
+    methods.forEach((methodName) => {
+        Prototype[methodName] = function () {
+            const args = arguments;
+            return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args));
+        };
+    });
+};
+const proxyOutputs = (instance, el, events) => {
+    events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName)));
+};
+const defineCustomElement = (tagName, customElement) => {
+    if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+        customElements.define(tagName, customElement);
+    }
+};
+// tslint:disable-next-line: only-arrow-functions
+function ProxyCmp(opts) {
+    const decorator = function (cls) {
+        const { defineCustomElementFn, inputs, methods } = opts;
+        if (defineCustomElementFn !== undefined) {
+            defineCustomElementFn();
+        }
+        if (inputs) {
+            proxyInputs(cls, inputs);
+        }
+        if (methods) {
+            proxyMethods(cls, methods);
+        }
+        return cls;
+    };
+    return decorator;
+}
+
+let SixAlert = class SixAlert {
+    z;
+    el;
+    sixAlertShow = new EventEmitter();
+    sixAlertAfterShow = new EventEmitter();
+    sixAlertHide = new EventEmitter();
+    sixAlertAfterHide = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixAlert, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixAlert, isStandalone: false, selector: "six-alert", inputs: { closable: "closable", duration: "duration", open: "open", type: "type" }, outputs: { sixAlertShow: "sixAlertShow", sixAlertAfterShow: "sixAlertAfterShow", sixAlertHide: "sixAlertHide", sixAlertAfterHide: "sixAlertAfterHide" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixAlert = __decorate([
+    ProxyCmp({
+        inputs: ['closable', 'duration', 'open', 'type'],
+        methods: ['show', 'hide', 'toast']
+    })
+], SixAlert);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixAlert, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-alert',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['closable', 'duration', 'open', 'type'],
+                    outputs: ['sixAlertShow:six-alert-show', 'sixAlertAfterShow:six-alert-after-show', 'sixAlertHide:six-alert-hide', 'sixAlertAfterHide:six-alert-after-hide'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixAlertShow: [{
+                type: Output
+            }], sixAlertAfterShow: [{
+                type: Output
+            }], sixAlertHide: [{
+                type: Output
+            }], sixAlertAfterHide: [{
+                type: Output
+            }] } });
+let SixAvatar = class SixAvatar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixAvatar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixAvatar, isStandalone: false, selector: "six-avatar", inputs: { alt: "alt", image: "image", initials: "initials", shape: "shape" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixAvatar = __decorate([
+    ProxyCmp({
+        inputs: ['alt', 'image', 'initials', 'shape']
+    })
+], SixAvatar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixAvatar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-avatar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['alt', 'image', 'initials', 'shape'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixBadge = class SixBadge {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixBadge, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixBadge, isStandalone: false, selector: "six-badge", inputs: { pill: "pill", pulse: "pulse", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixBadge = __decorate([
+    ProxyCmp({
+        inputs: ['pill', 'pulse', 'type']
+    })
+], SixBadge);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-badge',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['pill', 'pulse', 'type'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixBreadcrumbs = class SixBreadcrumbs {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixBreadcrumbs, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixBreadcrumbs, isStandalone: false, selector: "six-breadcrumbs", inputs: { separatorIcon: "separatorIcon", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixBreadcrumbs = __decorate([
+    ProxyCmp({
+        inputs: ['separatorIcon', 'size']
+    })
+], SixBreadcrumbs);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixBreadcrumbs, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-breadcrumbs',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['separatorIcon', 'size'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixBreadcrumbsItem = class SixBreadcrumbsItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixBreadcrumbsItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixBreadcrumbsItem, isStandalone: false, selector: "six-breadcrumbs-item", inputs: { href: "href", readonly: "readonly", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixBreadcrumbsItem = __decorate([
+    ProxyCmp({
+        inputs: ['href', 'readonly', 'target']
+    })
+], SixBreadcrumbsItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixBreadcrumbsItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-breadcrumbs-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['href', 'readonly', 'target'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixButton = class SixButton {
+    z;
+    el;
+    sixButtonBlur = new EventEmitter();
+    sixButtonFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixButton, isStandalone: false, selector: "six-button", inputs: { caret: "caret", circle: "circle", disabled: "disabled", download: "download", href: "href", loading: "loading", name: "name", pill: "pill", reset: "reset", size: "size", submit: "submit", target: "target", type: "type", value: "value" }, outputs: { sixButtonBlur: "sixButtonBlur", sixButtonFocus: "sixButtonFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixButton = __decorate([
+    ProxyCmp({
+        inputs: ['caret', 'circle', 'disabled', 'download', 'href', 'loading', 'name', 'pill', 'reset', 'size', 'submit', 'target', 'type', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], SixButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['caret', 'circle', 'disabled', 'download', 'href', 'loading', 'name', 'pill', 'reset', 'size', 'submit', 'target', 'type', 'value'],
+                    outputs: ['sixButtonBlur:six-button-blur', 'sixButtonFocus:six-button-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixButtonBlur: [{
+                type: Output
+            }], sixButtonFocus: [{
+                type: Output
+            }] } });
+let SixCard = class SixCard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixCard, isStandalone: false, selector: "six-card", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixCard = __decorate([
+    ProxyCmp({})
+], SixCard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixCheckbox = class SixCheckbox {
+    z;
+    el;
+    sixCheckboxBlur = new EventEmitter();
+    sixCheckboxChange = new EventEmitter();
+    sixCheckboxFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixCheckbox, isStandalone: false, selector: "six-checkbox", inputs: { checked: "checked", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", indeterminate: "indeterminate", invalid: "invalid", label: "label", name: "name", required: "required", value: "value" }, outputs: { sixCheckboxBlur: "sixCheckboxBlur", sixCheckboxChange: "sixCheckboxChange", sixCheckboxFocus: "sixCheckboxFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixCheckbox = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'disabled', 'errorText', 'errorTextCount', 'indeterminate', 'invalid', 'label', 'name', 'required', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], SixCheckbox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixCheckbox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-checkbox',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['checked', 'disabled', 'errorText', 'errorTextCount', 'indeterminate', 'invalid', 'label', 'name', 'required', 'value'],
+                    outputs: ['sixCheckboxBlur:six-checkbox-blur', 'sixCheckboxChange:six-checkbox-change', 'sixCheckboxFocus:six-checkbox-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixCheckboxBlur: [{
+                type: Output
+            }], sixCheckboxChange: [{
+                type: Output
+            }], sixCheckboxFocus: [{
+                type: Output
+            }] } });
+let SixDate = class SixDate {
+    z;
+    el;
+    sixChange = new EventEmitter();
+    sixBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDate, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixDate, isStandalone: false, selector: "six-date", inputs: { allowedDates: "allowedDates", clearable: "clearable", dateFormat: "dateFormat", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", helpText: "helpText", invalid: "invalid", label: "label", language: "language", max: "max", min: "min", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", size: "size", value: "value" }, outputs: { sixChange: "sixChange", sixBlur: "sixBlur" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixDate = __decorate([
+    ProxyCmp({
+        inputs: ['allowedDates', 'clearable', 'dateFormat', 'disabled', 'errorText', 'errorTextCount', 'helpText', 'invalid', 'label', 'language', 'max', 'min', 'name', 'placeholder', 'readonly', 'required', 'size', 'value'],
+        methods: ['setFocus']
+    })
+], SixDate);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDate, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-date',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['allowedDates', 'clearable', 'dateFormat', 'disabled', 'errorText', 'errorTextCount', 'helpText', 'invalid', 'label', 'language', 'max', 'min', 'name', 'placeholder', 'readonly', 'required', 'size', 'value'],
+                    outputs: ['sixChange:six-change', 'sixBlur:six-blur'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixChange: [{
+                type: Output
+            }], sixBlur: [{
+                type: Output
+            }] } });
+let SixDatepicker = class SixDatepicker {
+    z;
+    el;
+    sixDatepickerSelect = new EventEmitter();
+    sixDatepickerClear = new EventEmitter();
+    sixDatepickerBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDatepicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixDatepicker, isStandalone: false, selector: "six-datepicker", inputs: { allowedDates: "allowedDates", clearable: "clearable", closeOnSelect: "closeOnSelect", containingElement: "containingElement", dateFormat: "dateFormat", debounce: "debounce", defaultDate: "defaultDate", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", hoist: "hoist", iconPosition: "iconPosition", inline: "inline", invalid: "invalid", label: "label", locale: "locale", max: "max", min: "min", name: "name", open: "open", placeholder: "placeholder", placement: "placement", readonly: "readonly", required: "required", size: "size", type: "type", value: "value" }, outputs: { sixDatepickerSelect: "sixDatepickerSelect", sixDatepickerClear: "sixDatepickerClear", sixDatepickerBlur: "sixDatepickerBlur" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixDatepicker = __decorate([
+    ProxyCmp({
+        inputs: ['allowedDates', 'clearable', 'closeOnSelect', 'containingElement', 'dateFormat', 'debounce', 'defaultDate', 'disabled', 'errorText', 'errorTextCount', 'hoist', 'iconPosition', 'inline', 'invalid', 'label', 'locale', 'max', 'min', 'name', 'open', 'placeholder', 'placement', 'readonly', 'required', 'size', 'type', 'value'],
+        methods: ['setFocus', 'select']
+    })
+], SixDatepicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDatepicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-datepicker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['allowedDates', 'clearable', 'closeOnSelect', 'containingElement', 'dateFormat', 'debounce', 'defaultDate', 'disabled', 'errorText', 'errorTextCount', 'hoist', 'iconPosition', 'inline', 'invalid', 'label', 'locale', 'max', 'min', 'name', 'open', 'placeholder', 'placement', 'readonly', 'required', 'size', 'type', 'value'],
+                    outputs: ['sixDatepickerSelect:six-datepicker-select', 'sixDatepickerClear:six-datepicker-clear', 'sixDatepickerBlur:six-datepicker-blur'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixDatepickerSelect: [{
+                type: Output
+            }], sixDatepickerClear: [{
+                type: Output
+            }], sixDatepickerBlur: [{
+                type: Output
+            }] } });
+let SixDetails = class SixDetails {
+    z;
+    el;
+    sixDetailsShow = new EventEmitter();
+    sixDetailsAfterShow = new EventEmitter();
+    sixDetailsHide = new EventEmitter();
+    sixDetailsAfterHide = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDetails, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixDetails, isStandalone: false, selector: "six-details", inputs: { disabled: "disabled", hasContent: "hasContent", inline: "inline", open: "open", selectableEmpty: "selectableEmpty", summary: "summary", summaryIcon: "summaryIcon", summaryIconSize: "summaryIconSize" }, outputs: { sixDetailsShow: "sixDetailsShow", sixDetailsAfterShow: "sixDetailsAfterShow", sixDetailsHide: "sixDetailsHide", sixDetailsAfterHide: "sixDetailsAfterHide" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixDetails = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'hasContent', 'inline', 'open', 'selectableEmpty', 'summary', 'summaryIcon', 'summaryIconSize'],
+        methods: ['show', 'hide']
+    })
+], SixDetails);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDetails, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-details',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'hasContent', 'inline', 'open', 'selectableEmpty', 'summary', 'summaryIcon', 'summaryIconSize'],
+                    outputs: ['sixDetailsShow:six-details-show', 'sixDetailsAfterShow:six-details-after-show', 'sixDetailsHide:six-details-hide', 'sixDetailsAfterHide:six-details-after-hide'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixDetailsShow: [{
+                type: Output
+            }], sixDetailsAfterShow: [{
+                type: Output
+            }], sixDetailsHide: [{
+                type: Output
+            }], sixDetailsAfterHide: [{
+                type: Output
+            }] } });
+let SixDialog = class SixDialog {
+    z;
+    el;
+    sixDialogShow = new EventEmitter();
+    sixDialogAfterShow = new EventEmitter();
+    sixDialogHide = new EventEmitter();
+    sixDialogAfterHide = new EventEmitter();
+    sixDialogInitialFocus = new EventEmitter();
+    sixDialogRequestClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDialog, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixDialog, isStandalone: false, selector: "six-dialog", inputs: { label: "label", noHeader: "noHeader", open: "open" }, outputs: { sixDialogShow: "sixDialogShow", sixDialogAfterShow: "sixDialogAfterShow", sixDialogHide: "sixDialogHide", sixDialogAfterHide: "sixDialogAfterHide", sixDialogInitialFocus: "sixDialogInitialFocus", sixDialogRequestClose: "sixDialogRequestClose" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixDialog = __decorate([
+    ProxyCmp({
+        inputs: ['label', 'noHeader', 'open'],
+        methods: ['show', 'hide']
+    })
+], SixDialog);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDialog, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-dialog',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['label', 'noHeader', 'open'],
+                    outputs: ['sixDialogShow:six-dialog-show', 'sixDialogAfterShow:six-dialog-after-show', 'sixDialogHide:six-dialog-hide', 'sixDialogAfterHide:six-dialog-after-hide', 'sixDialogInitialFocus:six-dialog-initial-focus', 'sixDialogRequestClose:six-dialog-request-close'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixDialogShow: [{
+                type: Output
+            }], sixDialogAfterShow: [{
+                type: Output
+            }], sixDialogHide: [{
+                type: Output
+            }], sixDialogAfterHide: [{
+                type: Output
+            }], sixDialogInitialFocus: [{
+                type: Output
+            }], sixDialogRequestClose: [{
+                type: Output
+            }] } });
+let SixDrawer = class SixDrawer {
+    z;
+    el;
+    sixDrawerShow = new EventEmitter();
+    sixDrawerAfterShow = new EventEmitter();
+    sixDrawerHide = new EventEmitter();
+    sixDrawerAfterHide = new EventEmitter();
+    sixDrawerInitialFocus = new EventEmitter();
+    sixDrawerRequestClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDrawer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixDrawer, isStandalone: false, selector: "six-drawer", inputs: { contained: "contained", label: "label", noHeader: "noHeader", open: "open", placement: "placement" }, outputs: { sixDrawerShow: "sixDrawerShow", sixDrawerAfterShow: "sixDrawerAfterShow", sixDrawerHide: "sixDrawerHide", sixDrawerAfterHide: "sixDrawerAfterHide", sixDrawerInitialFocus: "sixDrawerInitialFocus", sixDrawerRequestClose: "sixDrawerRequestClose" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixDrawer = __decorate([
+    ProxyCmp({
+        inputs: ['contained', 'label', 'noHeader', 'open', 'placement'],
+        methods: ['show', 'hide']
+    })
+], SixDrawer);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDrawer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-drawer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['contained', 'label', 'noHeader', 'open', 'placement'],
+                    outputs: ['sixDrawerShow:six-drawer-show', 'sixDrawerAfterShow:six-drawer-after-show', 'sixDrawerHide:six-drawer-hide', 'sixDrawerAfterHide:six-drawer-after-hide', 'sixDrawerInitialFocus:six-drawer-initial-focus', 'sixDrawerRequestClose:six-drawer-request-close'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixDrawerShow: [{
+                type: Output
+            }], sixDrawerAfterShow: [{
+                type: Output
+            }], sixDrawerHide: [{
+                type: Output
+            }], sixDrawerAfterHide: [{
+                type: Output
+            }], sixDrawerInitialFocus: [{
+                type: Output
+            }], sixDrawerRequestClose: [{
+                type: Output
+            }] } });
+let SixDropdown = class SixDropdown {
+    z;
+    el;
+    sixDropdownShow = new EventEmitter();
+    sixDropdownAfterShow = new EventEmitter();
+    sixDropdownHide = new EventEmitter();
+    sixDropdownAfterHide = new EventEmitter();
+    sixDropdownAutoFilterFired = new EventEmitter();
+    sixAsyncFilterFired = new EventEmitter();
+    sixDropdownScroll = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDropdown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixDropdown, isStandalone: false, selector: "six-dropdown", inputs: { asyncFilter: "asyncFilter", autofocusFilter: "autofocusFilter", closeOnSelect: "closeOnSelect", containingElement: "containingElement", disableHideOnEnterAndSpace: "disableHideOnEnterAndSpace", disableTypeToSelect: "disableTypeToSelect", distance: "distance", filter: "filter", filterDebounce: "filterDebounce", filterPlaceholder: "filterPlaceholder", hoist: "hoist", matchTriggerWidth: "matchTriggerWidth", noScroll: "noScroll", open: "open", options: "options", placement: "placement", skidding: "skidding", virtualScroll: "virtualScroll" }, outputs: { sixDropdownShow: "sixDropdownShow", sixDropdownAfterShow: "sixDropdownAfterShow", sixDropdownHide: "sixDropdownHide", sixDropdownAfterHide: "sixDropdownAfterHide", sixDropdownAutoFilterFired: "sixDropdownAutoFilterFired", sixAsyncFilterFired: "sixAsyncFilterFired", sixDropdownScroll: "sixDropdownScroll" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixDropdown = __decorate([
+    ProxyCmp({
+        inputs: ['asyncFilter', 'autofocusFilter', 'closeOnSelect', 'containingElement', 'disableHideOnEnterAndSpace', 'disableTypeToSelect', 'distance', 'filter', 'filterDebounce', 'filterPlaceholder', 'hoist', 'matchTriggerWidth', 'noScroll', 'open', 'options', 'placement', 'skidding', 'virtualScroll'],
+        methods: ['show', 'hide']
+    })
+], SixDropdown);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixDropdown, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-dropdown',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['asyncFilter', 'autofocusFilter', 'closeOnSelect', 'containingElement', 'disableHideOnEnterAndSpace', 'disableTypeToSelect', 'distance', 'filter', 'filterDebounce', 'filterPlaceholder', 'hoist', 'matchTriggerWidth', 'noScroll', 'open', 'options', 'placement', 'skidding', 'virtualScroll'],
+                    outputs: ['sixDropdownShow:six-dropdown-show', 'sixDropdownAfterShow:six-dropdown-after-show', 'sixDropdownHide:six-dropdown-hide', 'sixDropdownAfterHide:six-dropdown-after-hide', 'sixDropdownAutoFilterFired:six-dropdown-auto-filter-fired', 'sixAsyncFilterFired:six-async-filter-fired', 'sixDropdownScroll:six-dropdown-scroll'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixDropdownShow: [{
+                type: Output
+            }], sixDropdownAfterShow: [{
+                type: Output
+            }], sixDropdownHide: [{
+                type: Output
+            }], sixDropdownAfterHide: [{
+                type: Output
+            }], sixDropdownAutoFilterFired: [{
+                type: Output
+            }], sixAsyncFilterFired: [{
+                type: Output
+            }], sixDropdownScroll: [{
+                type: Output
+            }] } });
+let SixError = class SixError {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixError, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixError, isStandalone: false, selector: "six-error", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixError = __decorate([
+    ProxyCmp({})
+], SixError);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixError, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-error',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixErrorPage = class SixErrorPage {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixErrorPage, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixErrorPage, isStandalone: false, selector: "six-error-page", inputs: { customDescription: "customDescription", customIcon: "customIcon", customTitle: "customTitle", errorCode: "errorCode", language: "language" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixErrorPage = __decorate([
+    ProxyCmp({
+        inputs: ['customDescription', 'customIcon', 'customTitle', 'errorCode', 'language']
+    })
+], SixErrorPage);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixErrorPage, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-error-page',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['customDescription', 'customIcon', 'customTitle', 'errorCode', 'language'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixFileList = class SixFileList {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFileList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixFileList, isStandalone: false, selector: "six-file-list", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixFileList = __decorate([
+    ProxyCmp({})
+], SixFileList);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFileList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-file-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixFileListItem = class SixFileListItem {
+    z;
+    el;
+    sixFileListItemDownload = new EventEmitter();
+    sixFileListItemRemove = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFileListItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixFileListItem, isStandalone: false, selector: "six-file-list-item", inputs: { date: "date", identifier: "identifier", name: "name", nodelete: "nodelete", nodownload: "nodownload", size: "size" }, outputs: { sixFileListItemDownload: "sixFileListItemDownload", sixFileListItemRemove: "sixFileListItemRemove" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixFileListItem = __decorate([
+    ProxyCmp({
+        inputs: ['date', 'identifier', 'name', 'nodelete', 'nodownload', 'size']
+    })
+], SixFileListItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFileListItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-file-list-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['date', 'identifier', 'name', 'nodelete', 'nodownload', 'size'],
+                    outputs: ['sixFileListItemDownload:six-file-list-item-download', 'sixFileListItemRemove:six-file-list-item-remove'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixFileListItemDownload: [{
+                type: Output
+            }], sixFileListItemRemove: [{
+                type: Output
+            }] } });
+let SixFileUpload = class SixFileUpload {
+    z;
+    el;
+    sixFileUploadSuccess = new EventEmitter();
+    sixFileUploadFailure = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFileUpload, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixFileUpload, isStandalone: false, selector: "six-file-upload", inputs: { accept: "accept", compact: "compact", disabled: "disabled", errorText: "errorText", invalid: "invalid", label: "label", maxFileSize: "maxFileSize", multiple: "multiple", uploading: "uploading" }, outputs: { sixFileUploadSuccess: "sixFileUploadSuccess", sixFileUploadFailure: "sixFileUploadFailure" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixFileUpload = __decorate([
+    ProxyCmp({
+        inputs: ['accept', 'compact', 'disabled', 'errorText', 'invalid', 'label', 'maxFileSize', 'multiple', 'uploading']
+    })
+], SixFileUpload);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFileUpload, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-file-upload',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['accept', 'compact', 'disabled', 'errorText', 'invalid', 'label', 'maxFileSize', 'multiple', 'uploading'],
+                    outputs: ['sixFileUploadSuccess:six-file-upload-success', 'sixFileUploadFailure:six-file-upload-failure'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixFileUploadSuccess: [{
+                type: Output
+            }], sixFileUploadFailure: [{
+                type: Output
+            }] } });
+let SixFooter = class SixFooter {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFooter, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixFooter, isStandalone: false, selector: "six-footer", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixFooter = __decorate([
+    ProxyCmp({})
+], SixFooter);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFooter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-footer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixGroupLabel = class SixGroupLabel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixGroupLabel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixGroupLabel, isStandalone: false, selector: "six-group-label", inputs: { disabled: "disabled", helpText: "helpText", label: "label", required: "required", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixGroupLabel = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'helpText', 'label', 'required', 'size']
+    })
+], SixGroupLabel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixGroupLabel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-group-label',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'helpText', 'label', 'required', 'size'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixHeader = class SixHeader {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeader, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixHeader, isStandalone: false, selector: "six-header", inputs: { openSearch: "openSearch", shiftContent: "shiftContent" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixHeader = __decorate([
+    ProxyCmp({
+        inputs: ['openSearch', 'shiftContent']
+    })
+], SixHeader);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-header',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['openSearch', 'shiftContent'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixHeaderDropdownItem = class SixHeaderDropdownItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeaderDropdownItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixHeaderDropdownItem, isStandalone: false, selector: "six-header-dropdown-item", inputs: { filter: "filter", filterPlaceholder: "filterPlaceholder" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixHeaderDropdownItem = __decorate([
+    ProxyCmp({
+        inputs: ['filter', 'filterPlaceholder']
+    })
+], SixHeaderDropdownItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeaderDropdownItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-header-dropdown-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['filter', 'filterPlaceholder'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixHeaderItem = class SixHeaderItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeaderItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixHeaderItem, isStandalone: false, selector: "six-header-item", inputs: { active: "active" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixHeaderItem = __decorate([
+    ProxyCmp({
+        inputs: ['active']
+    })
+], SixHeaderItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeaderItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-header-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixHeaderMenuButton = class SixHeaderMenuButton {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeaderMenuButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixHeaderMenuButton, isStandalone: false, selector: "six-header-menu-button", inputs: { caret: "caret", disabled: "disabled", loading: "loading", reset: "reset", submit: "submit" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixHeaderMenuButton = __decorate([
+    ProxyCmp({
+        inputs: ['caret', 'disabled', 'loading', 'reset', 'submit']
+    })
+], SixHeaderMenuButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixHeaderMenuButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-header-menu-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['caret', 'disabled', 'loading', 'reset', 'submit'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixIcon = class SixIcon {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixIcon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixIcon, isStandalone: false, selector: "six-icon", inputs: { filled: "filled", inlineSvg: "inlineSvg", library: "library", name: "name", size: "size", src: "src" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixIcon = __decorate([
+    ProxyCmp({
+        inputs: ['filled', 'inlineSvg', 'library', 'name', 'size', 'src']
+    })
+], SixIcon);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixIcon, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-icon',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['filled', 'inlineSvg', 'library', 'name', 'size', 'src'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixIconButton = class SixIconButton {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixIconButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixIconButton, isStandalone: false, selector: "six-icon-button", inputs: { disabled: "disabled", download: "download", href: "href", html: "html", label: "label", library: "library", name: "name", size: "size", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixIconButton = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'download', 'href', 'html', 'label', 'library', 'name', 'size', 'target']
+    })
+], SixIconButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixIconButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-icon-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'download', 'href', 'html', 'label', 'library', 'name', 'size', 'target'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixInput = class SixInput {
+    z;
+    el;
+    sixInputChange = new EventEmitter();
+    sixInputClear = new EventEmitter();
+    sixInputInput = new EventEmitter();
+    sixInputFocus = new EventEmitter();
+    sixInputBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixInput, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixInput, isStandalone: false, selector: "six-input", inputs: { autocapitalize: "autocapitalize", autocomplete: "autocomplete", autocorrect: "autocorrect", autofocus: "autofocus", clearable: "clearable", disabled: "disabled", dropdownSearch: "dropdownSearch", errorText: "errorText", errorTextCount: "errorTextCount", helpText: "helpText", inputmode: "inputmode", invalid: "invalid", label: "label", line: "line", max: "max", maxlength: "maxlength", min: "min", minlength: "minlength", name: "name", pattern: "pattern", pill: "pill", placeholder: "placeholder", readonly: "readonly", required: "required", size: "size", spellcheck: "spellcheck", step: "step", togglePassword: "togglePassword", type: "type", value: "value" }, outputs: { sixInputChange: "sixInputChange", sixInputClear: "sixInputClear", sixInputInput: "sixInputInput", sixInputFocus: "sixInputFocus", sixInputBlur: "sixInputBlur" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixInput = __decorate([
+    ProxyCmp({
+        inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearable', 'disabled', 'dropdownSearch', 'errorText', 'errorTextCount', 'helpText', 'inputmode', 'invalid', 'label', 'line', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'pill', 'placeholder', 'readonly', 'required', 'size', 'spellcheck', 'step', 'togglePassword', 'type', 'value'],
+        methods: ['setFocus', 'removeFocus', 'select', 'setSelectionRange', 'getSelectionRange', 'setRangeText']
+    })
+], SixInput);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-input',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearable', 'disabled', 'dropdownSearch', 'errorText', 'errorTextCount', 'helpText', 'inputmode', 'invalid', 'label', 'line', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'pill', 'placeholder', 'readonly', 'required', 'size', 'spellcheck', 'step', 'togglePassword', 'type', 'value'],
+                    outputs: ['sixInputChange:six-input-change', 'sixInputClear:six-input-clear', 'sixInputInput:six-input-input', 'sixInputFocus:six-input-focus', 'sixInputBlur:six-input-blur'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixInputChange: [{
+                type: Output
+            }], sixInputClear: [{
+                type: Output
+            }], sixInputInput: [{
+                type: Output
+            }], sixInputFocus: [{
+                type: Output
+            }], sixInputBlur: [{
+                type: Output
+            }] } });
+let SixItemPicker = class SixItemPicker {
+    z;
+    el;
+    sixItemPickerChange = new EventEmitter();
+    sixItemPickerChangeDebounced = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixItemPicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixItemPicker, isStandalone: false, selector: "six-item-picker", inputs: { debounce: "debounce", interval: "interval", items: "items", max: "max", min: "min", padded: "padded", paddingChar: "paddingChar", paddingDirection: "paddingDirection", paddingLength: "paddingLength", roundtrip: "roundtrip", step: "step", timeout: "timeout", type: "type", value: "value" }, outputs: { sixItemPickerChange: "sixItemPickerChange", sixItemPickerChangeDebounced: "sixItemPickerChangeDebounced" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixItemPicker = __decorate([
+    ProxyCmp({
+        inputs: ['debounce', 'interval', 'items', 'max', 'min', 'padded', 'paddingChar', 'paddingDirection', 'paddingLength', 'roundtrip', 'step', 'timeout', 'type', 'value']
+    })
+], SixItemPicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixItemPicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-item-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['debounce', 'interval', 'items', 'max', 'min', 'padded', 'paddingChar', 'paddingDirection', 'paddingLength', 'roundtrip', 'step', 'timeout', 'type', 'value'],
+                    outputs: ['sixItemPickerChange:six-item-picker-change', 'sixItemPickerChangeDebounced:six-item-picker-change-debounced'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixItemPickerChange: [{
+                type: Output
+            }], sixItemPickerChangeDebounced: [{
+                type: Output
+            }] } });
+let SixLanguageSwitcher = class SixLanguageSwitcher {
+    z;
+    el;
+    sixLanguageSwitcherChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixLanguageSwitcher, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixLanguageSwitcher, isStandalone: false, selector: "six-language-switcher", inputs: { languages: "languages", selected: "selected" }, outputs: { sixLanguageSwitcherChange: "sixLanguageSwitcherChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixLanguageSwitcher = __decorate([
+    ProxyCmp({
+        inputs: ['languages', 'selected']
+    })
+], SixLanguageSwitcher);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixLanguageSwitcher, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-language-switcher',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['languages', 'selected'],
+                    outputs: ['sixLanguageSwitcherChange:six-language-switcher-change'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixLanguageSwitcherChange: [{
+                type: Output
+            }] } });
+let SixLayoutGrid = class SixLayoutGrid {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixLayoutGrid, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixLayoutGrid, isStandalone: false, selector: "six-layout-grid", inputs: { columns: "columns" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixLayoutGrid = __decorate([
+    ProxyCmp({
+        inputs: ['columns']
+    })
+], SixLayoutGrid);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixLayoutGrid, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-layout-grid',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['columns'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixLogo = class SixLogo {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixLogo, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixLogo, isStandalone: false, selector: "six-logo", inputs: { brand: "brand" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixLogo = __decorate([
+    ProxyCmp({
+        inputs: ['brand']
+    })
+], SixLogo);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixLogo, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-logo',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['brand'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixMainContainer = class SixMainContainer {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMainContainer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixMainContainer, isStandalone: false, selector: "six-main-container", inputs: { padded: "padded" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixMainContainer = __decorate([
+    ProxyCmp({
+        inputs: ['padded']
+    })
+], SixMainContainer);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMainContainer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-main-container',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['padded'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixMenu = class SixMenu {
+    z;
+    el;
+    sixMenuItemSelected = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixMenu, isStandalone: false, selector: "six-menu", inputs: { disableKeyboardHandling: "disableKeyboardHandling", itemSize: "itemSize", items: "items", itemsShown: "itemsShown", removeBoxShadow: "removeBoxShadow", scrollingDebounce: "scrollingDebounce", virtualScroll: "virtualScroll" }, outputs: { sixMenuItemSelected: "sixMenuItemSelected" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixMenu = __decorate([
+    ProxyCmp({
+        inputs: ['disableKeyboardHandling', 'itemSize', 'items', 'itemsShown', 'removeBoxShadow', 'scrollingDebounce', 'virtualScroll'],
+        methods: ['typeToSelect']
+    })
+], SixMenu);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenu, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-menu',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disableKeyboardHandling', 'itemSize', 'items', 'itemsShown', 'removeBoxShadow', 'scrollingDebounce', 'virtualScroll'],
+                    outputs: ['sixMenuItemSelected:six-menu-item-selected'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixMenuItemSelected: [{
+                type: Output
+            }] } });
+let SixMenuDivider = class SixMenuDivider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenuDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixMenuDivider, isStandalone: false, selector: "six-menu-divider", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixMenuDivider = __decorate([
+    ProxyCmp({})
+], SixMenuDivider);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenuDivider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-menu-divider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixMenuItem = class SixMenuItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenuItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixMenuItem, isStandalone: false, selector: "six-menu-item", inputs: { checkType: "checkType", checked: "checked", disabled: "disabled", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixMenuItem = __decorate([
+    ProxyCmp({
+        inputs: ['checkType', 'checked', 'disabled', 'value'],
+        methods: ['setFocus', 'removeFocus', 'getTextLabel']
+    })
+], SixMenuItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenuItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-menu-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['checkType', 'checked', 'disabled', 'value'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixMenuLabel = class SixMenuLabel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenuLabel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixMenuLabel, isStandalone: false, selector: "six-menu-label", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixMenuLabel = __decorate([
+    ProxyCmp({})
+], SixMenuLabel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixMenuLabel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-menu-label',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixPaginator = class SixPaginator {
+    z;
+    el;
+    sixPaginatorResultsPerPageChanged = new EventEmitter();
+    sixPaginatorPageChanged = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixPaginator, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixPaginator, isStandalone: false, selector: "six-paginator", inputs: { clamp: "clamp", currentPage: "currentPage", disabled: "disabled", length: "length", resultsPerPage: "resultsPerPage", resultsPerPageOptions: "resultsPerPageOptions", totalPages: "totalPages", totalResults: "totalResults" }, outputs: { sixPaginatorResultsPerPageChanged: "sixPaginatorResultsPerPageChanged", sixPaginatorPageChanged: "sixPaginatorPageChanged" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixPaginator = __decorate([
+    ProxyCmp({
+        inputs: ['clamp', 'currentPage', 'disabled', 'length', 'resultsPerPage', 'resultsPerPageOptions', 'totalPages', 'totalResults']
+    })
+], SixPaginator);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixPaginator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-paginator',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clamp', 'currentPage', 'disabled', 'length', 'resultsPerPage', 'resultsPerPageOptions', { name: 'totalPages', required: true }, { name: 'totalResults', required: true }],
+                    outputs: ['sixPaginatorResultsPerPageChanged:six-paginator-results-per-page-changed', 'sixPaginatorPageChanged:six-paginator-page-changed'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixPaginatorResultsPerPageChanged: [{
+                type: Output
+            }], sixPaginatorPageChanged: [{
+                type: Output
+            }] } });
+let SixPicto = class SixPicto {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixPicto, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixPicto, isStandalone: false, selector: "six-picto", inputs: { size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixPicto = __decorate([
+    ProxyCmp({
+        inputs: ['size']
+    })
+], SixPicto);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixPicto, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-picto',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['size'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixProgressBar = class SixProgressBar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixProgressBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixProgressBar, isStandalone: false, selector: "six-progress-bar", inputs: { indeterminate: "indeterminate", percentage: "percentage" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixProgressBar = __decorate([
+    ProxyCmp({
+        inputs: ['indeterminate', 'percentage']
+    })
+], SixProgressBar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixProgressBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-progress-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['indeterminate', 'percentage'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixProgressRing = class SixProgressRing {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixProgressRing, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixProgressRing, isStandalone: false, selector: "six-progress-ring", inputs: { percentage: "percentage", size: "size", strokeWidth: "strokeWidth" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixProgressRing = __decorate([
+    ProxyCmp({
+        inputs: ['percentage', 'size', 'strokeWidth']
+    })
+], SixProgressRing);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixProgressRing, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-progress-ring',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['percentage', 'size', 'strokeWidth'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixRadio = class SixRadio {
+    z;
+    el;
+    sixRadioBlur = new EventEmitter();
+    sixRadioChange = new EventEmitter();
+    sixRadioFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRadio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixRadio, isStandalone: false, selector: "six-radio", inputs: { checked: "checked", disabled: "disabled", invalid: "invalid", name: "name", value: "value" }, outputs: { sixRadioBlur: "sixRadioBlur", sixRadioChange: "sixRadioChange", sixRadioFocus: "sixRadioFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixRadio = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'disabled', 'invalid', 'name', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], SixRadio);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRadio, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-radio',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['checked', 'disabled', 'invalid', 'name', 'value'],
+                    outputs: ['sixRadioBlur:six-radio-blur', 'sixRadioChange:six-radio-change', 'sixRadioFocus:six-radio-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixRadioBlur: [{
+                type: Output
+            }], sixRadioChange: [{
+                type: Output
+            }], sixRadioFocus: [{
+                type: Output
+            }] } });
+let SixRange = class SixRange {
+    z;
+    el;
+    sixRangeChange = new EventEmitter();
+    sixRangeBlur = new EventEmitter();
+    sixRangeFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRange, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixRange, isStandalone: false, selector: "six-range", inputs: { disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", helpText: "helpText", invalid: "invalid", label: "label", max: "max", min: "min", name: "name", required: "required", step: "step", tooltip: "tooltip", tooltipFormatter: "tooltipFormatter", value: "value" }, outputs: { sixRangeChange: "sixRangeChange", sixRangeBlur: "sixRangeBlur", sixRangeFocus: "sixRangeFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixRange = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'errorText', 'errorTextCount', 'helpText', 'invalid', 'label', 'max', 'min', 'name', 'required', 'step', 'tooltip', 'tooltipFormatter', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], SixRange);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRange, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-range',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'errorText', 'errorTextCount', 'helpText', 'invalid', 'label', 'max', 'min', 'name', 'required', 'step', 'tooltip', 'tooltipFormatter', 'value'],
+                    outputs: ['sixRangeChange:six-range-change', 'sixRangeBlur:six-range-blur', 'sixRangeFocus:six-range-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixRangeChange: [{
+                type: Output
+            }], sixRangeBlur: [{
+                type: Output
+            }], sixRangeFocus: [{
+                type: Output
+            }] } });
+let SixRating = class SixRating {
+    z;
+    el;
+    sixRatingBlur = new EventEmitter();
+    sixRatingChange = new EventEmitter();
+    sixRatingFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRating, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixRating, isStandalone: false, selector: "six-rating", inputs: { disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", helpText: "helpText", invalid: "invalid", label: "label", max: "max", name: "name", readonly: "readonly", required: "required", size: "size", value: "value" }, outputs: { sixRatingBlur: "sixRatingBlur", sixRatingChange: "sixRatingChange", sixRatingFocus: "sixRatingFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixRating = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'errorText', 'errorTextCount', 'helpText', 'invalid', 'label', 'max', 'name', 'readonly', 'required', 'size', 'value']
+    })
+], SixRating);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRating, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-rating',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'errorText', 'errorTextCount', 'helpText', 'invalid', 'label', 'max', 'name', 'readonly', 'required', 'size', 'value'],
+                    outputs: ['sixRatingBlur:six-rating-blur', 'sixRatingChange:six-rating-change', 'sixRatingFocus:six-rating-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixRatingBlur: [{
+                type: Output
+            }], sixRatingChange: [{
+                type: Output
+            }], sixRatingFocus: [{
+                type: Output
+            }] } });
+let SixRoot = class SixRoot {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRoot, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixRoot, isStandalone: false, selector: "six-root", inputs: { padded: "padded", stage: "stage", version: "version" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixRoot = __decorate([
+    ProxyCmp({
+        inputs: ['padded', 'stage', 'version']
+    })
+], SixRoot);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRoot, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-root',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['padded', 'stage', 'version'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixSearchField = class SixSearchField {
+    z;
+    el;
+    sixSearchFieldChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSearchField, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSearchField, isStandalone: false, selector: "six-search-field", inputs: { clearable: "clearable", debounce: "debounce", disabled: "disabled", placeholder: "placeholder", value: "value" }, outputs: { sixSearchFieldChange: "sixSearchFieldChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSearchField = __decorate([
+    ProxyCmp({
+        inputs: ['clearable', 'debounce', 'disabled', 'placeholder', 'value']
+    })
+], SixSearchField);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSearchField, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-search-field',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clearable', 'debounce', 'disabled', 'placeholder', 'value'],
+                    outputs: ['sixSearchFieldChange:six-search-field-change'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixSearchFieldChange: [{
+                type: Output
+            }] } });
+let SixSelect = class SixSelect {
+    z;
+    el;
+    sixSelectChange = new EventEmitter();
+    sixSelectFocus = new EventEmitter();
+    sixSelectBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSelect, isStandalone: false, selector: "six-select", inputs: { asyncFilter: "asyncFilter", autocomplete: "autocomplete", clearable: "clearable", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", filter: "filter", filterDebounce: "filterDebounce", filterPlaceholder: "filterPlaceholder", helpText: "helpText", hoist: "hoist", inputDebounce: "inputDebounce", invalid: "invalid", label: "label", line: "line", multiple: "multiple", name: "name", options: "options", pill: "pill", placeholder: "placeholder", required: "required", selectAllButton: "selectAllButton", selectAllText: "selectAllText", size: "size", value: "value", virtualScroll: "virtualScroll" }, outputs: { sixSelectChange: "sixSelectChange", sixSelectFocus: "sixSelectFocus", sixSelectBlur: "sixSelectBlur" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSelect = __decorate([
+    ProxyCmp({
+        inputs: ['asyncFilter', 'autocomplete', 'clearable', 'disabled', 'errorText', 'errorTextCount', 'filter', 'filterDebounce', 'filterPlaceholder', 'helpText', 'hoist', 'inputDebounce', 'invalid', 'label', 'line', 'multiple', 'name', 'options', 'pill', 'placeholder', 'required', 'selectAllButton', 'selectAllText', 'size', 'value', 'virtualScroll'],
+        methods: ['setFocus']
+    })
+], SixSelect);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-select',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['asyncFilter', 'autocomplete', 'clearable', 'disabled', 'errorText', 'errorTextCount', 'filter', 'filterDebounce', 'filterPlaceholder', 'helpText', 'hoist', 'inputDebounce', 'invalid', 'label', 'line', 'multiple', 'name', 'options', 'pill', 'placeholder', 'required', 'selectAllButton', 'selectAllText', 'size', 'value', 'virtualScroll'],
+                    outputs: ['sixSelectChange:six-select-change', 'sixSelectFocus:six-select-focus', 'sixSelectBlur:six-select-blur'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixSelectChange: [{
+                type: Output
+            }], sixSelectFocus: [{
+                type: Output
+            }], sixSelectBlur: [{
+                type: Output
+            }] } });
+let SixSidebar = class SixSidebar {
+    z;
+    el;
+    sixSidebarShow = new EventEmitter();
+    sixSidebarAfterShow = new EventEmitter();
+    sixSidebarHide = new EventEmitter();
+    sixSidebarAfterHide = new EventEmitter();
+    sixSidebarInitialFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSidebar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSidebar, isStandalone: false, selector: "six-sidebar", inputs: { open: "open", position: "position", toggled: "toggled", width: "width" }, outputs: { sixSidebarShow: "sixSidebarShow", sixSidebarAfterShow: "sixSidebarAfterShow", sixSidebarHide: "sixSidebarHide", sixSidebarAfterHide: "sixSidebarAfterHide", sixSidebarInitialFocus: "sixSidebarInitialFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSidebar = __decorate([
+    ProxyCmp({
+        inputs: ['open', 'position', 'toggled', 'width'],
+        methods: ['toggle', 'show', 'hide', 'selectItemByIndex', 'selectItemByName']
+    })
+], SixSidebar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSidebar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-sidebar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['open', 'position', 'toggled', 'width'],
+                    outputs: ['sixSidebarShow:six-sidebar-show', 'sixSidebarAfterShow:six-sidebar-after-show', 'sixSidebarHide:six-sidebar-hide', 'sixSidebarAfterHide:six-sidebar-after-hide', 'sixSidebarInitialFocus:six-sidebar-initial-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixSidebarShow: [{
+                type: Output
+            }], sixSidebarAfterShow: [{
+                type: Output
+            }], sixSidebarHide: [{
+                type: Output
+            }], sixSidebarAfterHide: [{
+                type: Output
+            }], sixSidebarInitialFocus: [{
+                type: Output
+            }] } });
+let SixSidebarItem = class SixSidebarItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSidebarItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSidebarItem, isStandalone: false, selector: "six-sidebar-item", inputs: { disabled: "disabled", href: "href", icon: "icon", selected: "selected", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSidebarItem = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'href', 'icon', 'selected', 'value']
+    })
+], SixSidebarItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSidebarItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-sidebar-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'href', 'icon', 'selected', 'value'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixSidebarItemGroup = class SixSidebarItemGroup {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSidebarItemGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSidebarItemGroup, isStandalone: false, selector: "six-sidebar-item-group", inputs: { href: "href", icon: "icon", name: "name", open: "open", summaryIcon: "summaryIcon", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSidebarItemGroup = __decorate([
+    ProxyCmp({
+        inputs: ['href', 'icon', 'name', 'open', 'summaryIcon', 'value']
+    })
+], SixSidebarItemGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSidebarItemGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-sidebar-item-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['href', 'icon', 'name', 'open', 'summaryIcon', 'value'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixSpinner = class SixSpinner {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSpinner, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSpinner, isStandalone: false, selector: "six-spinner", inputs: { logo: "logo", six: "six" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSpinner = __decorate([
+    ProxyCmp({
+        inputs: ['logo', 'six']
+    })
+], SixSpinner);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSpinner, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-spinner',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['logo', 'six'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixStageIndicator = class SixStageIndicator {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixStageIndicator, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixStageIndicator, isStandalone: false, selector: "six-stage-indicator", inputs: { stage: "stage" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixStageIndicator = __decorate([
+    ProxyCmp({
+        inputs: ['stage']
+    })
+], SixStageIndicator);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixStageIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-stage-indicator',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['stage'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixSwitch = class SixSwitch {
+    z;
+    el;
+    sixSwitchBlur = new EventEmitter();
+    sixSwitchChange = new EventEmitter();
+    sixSwitchFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSwitch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixSwitch, isStandalone: false, selector: "six-switch", inputs: { checked: "checked", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", invalid: "invalid", label: "label", name: "name", required: "required", value: "value" }, outputs: { sixSwitchBlur: "sixSwitchBlur", sixSwitchChange: "sixSwitchChange", sixSwitchFocus: "sixSwitchFocus" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixSwitch = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'disabled', 'errorText', 'errorTextCount', 'invalid', 'label', 'name', 'required', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], SixSwitch);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixSwitch, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-switch',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['checked', 'disabled', 'errorText', 'errorTextCount', 'invalid', 'label', 'name', 'required', 'value'],
+                    outputs: ['sixSwitchBlur:six-switch-blur', 'sixSwitchChange:six-switch-change', 'sixSwitchFocus:six-switch-focus'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixSwitchBlur: [{
+                type: Output
+            }], sixSwitchChange: [{
+                type: Output
+            }], sixSwitchFocus: [{
+                type: Output
+            }] } });
+let SixTab = class SixTab {
+    z;
+    el;
+    sixTabClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTab, isStandalone: false, selector: "six-tab", inputs: { active: "active", closable: "closable", disabled: "disabled", hoverContent: "hoverContent", panel: "panel" }, outputs: { sixTabClose: "sixTabClose" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTab = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'closable', 'disabled', 'hoverContent', 'panel'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], SixTab);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-tab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'closable', 'disabled', 'hoverContent', 'panel'],
+                    outputs: ['sixTabClose:six-tab-close'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTabClose: [{
+                type: Output
+            }] } });
+let SixTabGroup = class SixTabGroup {
+    z;
+    el;
+    sixTabShow = new EventEmitter();
+    sixTabHide = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTabGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTabGroup, isStandalone: false, selector: "six-tab-group", inputs: { noScrollControls: "noScrollControls", placement: "placement" }, outputs: { sixTabShow: "sixTabShow", sixTabHide: "sixTabHide" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTabGroup = __decorate([
+    ProxyCmp({
+        inputs: ['noScrollControls', 'placement'],
+        methods: ['show']
+    })
+], SixTabGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTabGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-tab-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['noScrollControls', 'placement'],
+                    outputs: ['sixTabShow:six-tab-show', 'sixTabHide:six-tab-hide'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTabShow: [{
+                type: Output
+            }], sixTabHide: [{
+                type: Output
+            }] } });
+let SixTabPanel = class SixTabPanel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTabPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTabPanel, isStandalone: false, selector: "six-tab-panel", inputs: { active: "active", name: "name" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTabPanel = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'name']
+    })
+], SixTabPanel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTabPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-tab-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'name'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let SixTag = class SixTag {
+    z;
+    el;
+    sixTagClear = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTag, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTag, isStandalone: false, selector: "six-tag", inputs: { clearable: "clearable", pill: "pill", size: "size", type: "type" }, outputs: { sixTagClear: "sixTagClear" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTag = __decorate([
+    ProxyCmp({
+        inputs: ['clearable', 'pill', 'size', 'type']
+    })
+], SixTag);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTag, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-tag',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clearable', 'pill', 'size', 'type'],
+                    outputs: ['sixTagClear:six-tag-clear'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTagClear: [{
+                type: Output
+            }] } });
+let SixTextarea = class SixTextarea {
+    z;
+    el;
+    sixTextareaChange = new EventEmitter();
+    sixTextareaInput = new EventEmitter();
+    sixTextareaFocus = new EventEmitter();
+    sixTextareaBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTextarea, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTextarea, isStandalone: false, selector: "six-textarea", inputs: { autocapitalize: "autocapitalize", autocomplete: "autocomplete", autocorrect: "autocorrect", autofocus: "autofocus", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", helpText: "helpText", inputmode: "inputmode", invalid: "invalid", label: "label", maxlength: "maxlength", minlength: "minlength", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", resize: "resize", rows: "rows", size: "size", spellcheck: "spellcheck", value: "value" }, outputs: { sixTextareaChange: "sixTextareaChange", sixTextareaInput: "sixTextareaInput", sixTextareaFocus: "sixTextareaFocus", sixTextareaBlur: "sixTextareaBlur" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTextarea = __decorate([
+    ProxyCmp({
+        inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'disabled', 'errorText', 'errorTextCount', 'helpText', 'inputmode', 'invalid', 'label', 'maxlength', 'minlength', 'name', 'placeholder', 'readonly', 'required', 'resize', 'rows', 'size', 'spellcheck', 'value'],
+        methods: ['setFocus', 'removeFocus', 'select', 'setSelectionRange', 'setRangeText']
+    })
+], SixTextarea);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTextarea, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-textarea',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'disabled', 'errorText', 'errorTextCount', 'helpText', 'inputmode', 'invalid', 'label', 'maxlength', 'minlength', 'name', 'placeholder', 'readonly', 'required', 'resize', 'rows', 'size', 'spellcheck', 'value'],
+                    outputs: ['sixTextareaChange:six-textarea-change', 'sixTextareaInput:six-textarea-input', 'sixTextareaFocus:six-textarea-focus', 'sixTextareaBlur:six-textarea-blur'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTextareaChange: [{
+                type: Output
+            }], sixTextareaInput: [{
+                type: Output
+            }], sixTextareaFocus: [{
+                type: Output
+            }], sixTextareaBlur: [{
+                type: Output
+            }] } });
+let SixTile = class SixTile {
+    z;
+    el;
+    sixTileClosed = new EventEmitter();
+    sixTileSelected = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTile, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTile, isStandalone: false, selector: "six-tile", inputs: { closeable: "closeable", disableTooltip: "disableTooltip", disabled: "disabled", elevated: "elevated", iconName: "iconName", label: "label", library: "library", size: "size" }, outputs: { sixTileClosed: "sixTileClosed", sixTileSelected: "sixTileSelected" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTile = __decorate([
+    ProxyCmp({
+        inputs: ['closeable', 'disableTooltip', 'disabled', 'elevated', 'iconName', 'label', 'library', 'size'],
+        methods: ['hide', 'show']
+    })
+], SixTile);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTile, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-tile',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['closeable', 'disableTooltip', 'disabled', 'elevated', 'iconName', 'label', 'library', 'size'],
+                    outputs: ['sixTileClosed:six-tile-closed', 'sixTileSelected:six-tile-selected'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTileClosed: [{
+                type: Output
+            }], sixTileSelected: [{
+                type: Output
+            }] } });
+let SixTimepicker = class SixTimepicker {
+    z;
+    el;
+    sixTimepickerChange = new EventEmitter();
+    sixTimepickerChangeDebounced = new EventEmitter();
+    sixTimepickerClear = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTimepicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTimepicker, isStandalone: false, selector: "six-timepicker", inputs: { clearable: "clearable", debounce: "debounce", defaultTime: "defaultTime", disabled: "disabled", errorText: "errorText", errorTextCount: "errorTextCount", format: "format", hoist: "hoist", iconPosition: "iconPosition", inline: "inline", interval: "interval", invalid: "invalid", label: "label", name: "name", open: "open", placeholder: "placeholder", placement: "placement", readonly: "readonly", required: "required", separator: "separator", size: "size", timeout: "timeout", value: "value" }, outputs: { sixTimepickerChange: "sixTimepickerChange", sixTimepickerChangeDebounced: "sixTimepickerChangeDebounced", sixTimepickerClear: "sixTimepickerClear" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTimepicker = __decorate([
+    ProxyCmp({
+        inputs: ['clearable', 'debounce', 'defaultTime', 'disabled', 'errorText', 'errorTextCount', 'format', 'hoist', 'iconPosition', 'inline', 'interval', 'invalid', 'label', 'name', 'open', 'placeholder', 'placement', 'readonly', 'required', 'separator', 'size', 'timeout', 'value'],
+        methods: ['setFocus']
+    })
+], SixTimepicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTimepicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-timepicker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clearable', 'debounce', 'defaultTime', 'disabled', 'errorText', 'errorTextCount', 'format', 'hoist', 'iconPosition', 'inline', 'interval', 'invalid', 'label', 'name', 'open', 'placeholder', 'placement', 'readonly', 'required', 'separator', 'size', 'timeout', 'value'],
+                    outputs: ['sixTimepickerChange:six-timepicker-change', 'sixTimepickerChangeDebounced:six-timepicker-change-debounced', 'sixTimepickerClear:six-timepicker-clear'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTimepickerChange: [{
+                type: Output
+            }], sixTimepickerChangeDebounced: [{
+                type: Output
+            }], sixTimepickerClear: [{
+                type: Output
+            }] } });
+let SixTooltip = class SixTooltip {
+    z;
+    el;
+    sixTooltipShow = new EventEmitter();
+    sixTooltipAfterShow = new EventEmitter();
+    sixTooltipHide = new EventEmitter();
+    sixTooltipAfterHide = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTooltip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.17", type: SixTooltip, isStandalone: false, selector: "six-tooltip", inputs: { content: "content", disabled: "disabled", distance: "distance", open: "open", placement: "placement", skidding: "skidding", trigger: "trigger" }, outputs: { sixTooltipShow: "sixTooltipShow", sixTooltipAfterShow: "sixTooltipAfterShow", sixTooltipHide: "sixTooltipHide", sixTooltipAfterHide: "sixTooltipAfterHide" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+SixTooltip = __decorate([
+    ProxyCmp({
+        inputs: ['content', 'disabled', 'distance', 'open', 'placement', 'skidding', 'trigger'],
+        methods: ['show', 'hide']
+    })
+], SixTooltip);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixTooltip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'six-tooltip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['content', 'disabled', 'distance', 'open', 'placement', 'skidding', 'trigger'],
+                    outputs: ['sixTooltipShow:six-tooltip-show', 'sixTooltipAfterShow:six-tooltip-after-show', 'sixTooltipHide:six-tooltip-hide', 'sixTooltipAfterHide:six-tooltip-after-hide'],
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { sixTooltipShow: [{
+                type: Output
+            }], sixTooltipAfterShow: [{
+                type: Output
+            }], sixTooltipHide: [{
+                type: Output
+            }], sixTooltipAfterHide: [{
+                type: Output
+            }] } });
+
+const DIRECTIVES = [
+    SixAlert,
+    SixAvatar,
+    SixBadge,
+    SixBreadcrumbs,
+    SixBreadcrumbsItem,
+    SixButton,
+    SixCard,
+    SixCheckbox,
+    SixDate,
+    SixDatepicker,
+    SixDetails,
+    SixDialog,
+    SixDrawer,
+    SixDropdown,
+    SixError,
+    SixErrorPage,
+    SixFileList,
+    SixFileListItem,
+    SixFileUpload,
+    SixFooter,
+    SixGroupLabel,
+    SixHeader,
+    SixHeaderDropdownItem,
+    SixHeaderItem,
+    SixHeaderMenuButton,
+    SixIcon,
+    SixIconButton,
+    SixInput,
+    SixItemPicker,
+    SixLanguageSwitcher,
+    SixLayoutGrid,
+    SixLogo,
+    SixMainContainer,
+    SixMenu,
+    SixMenuDivider,
+    SixMenuItem,
+    SixMenuLabel,
+    SixPaginator,
+    SixPicto,
+    SixProgressBar,
+    SixProgressRing,
+    SixRadio,
+    SixRange,
+    SixRating,
+    SixRoot,
+    SixSearchField,
+    SixSelect,
+    SixSidebar,
+    SixSidebarItem,
+    SixSidebarItemGroup,
+    SixSpinner,
+    SixStageIndicator,
+    SixSwitch,
+    SixTab,
+    SixTabGroup,
+    SixTabPanel,
+    SixTag,
+    SixTextarea,
+    SixTile,
+    SixTimepicker,
+    SixTooltip
+];
+
+class ValidationMessagesService {
+    getErrorMessage(language, error) {
+        return getErrorMessage(language, error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ValidationMessagesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ValidationMessagesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ValidationMessagesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const DEFAULT_UI_LIBRARY_CONFIG = {
+    showAsteriskOnRequiredValidator: false,
+    disableValidationService: false,
+};
+/**
+ * Injection token holding the {@link UiLibraryConfig}.
+ *
+ * The token provides {@link DEFAULT_UI_LIBRARY_CONFIG} by default, so that components and
+ * directives of this library can be used without calling `UiLibraryAngularModule.forRoot()`
+ * (e.g. in unit tests). Provide the token explicitly to override single options:
+ *
+ * ```ts
+ * TestBed.configureTestingModule({
+ *   providers: [{ provide: UI_LIBRARY_CONFIG, useValue: { showAsteriskOnRequiredValidator: true } }],
+ * });
+ * ```
+ */
+const UI_LIBRARY_CONFIG = new InjectionToken('UiLibraryConfig', {
+    providedIn: 'root',
+    factory: () => DEFAULT_UI_LIBRARY_CONFIG,
+});
+
+class ValueAccessor {
+    injector;
+    el;
+    statusChanges;
+    ngControl;
+    initialErrorText;
+    validationMessagesService = inject(ValidationMessagesService);
+    config = inject(UI_LIBRARY_CONFIG);
+    constructor(injector, el) {
+        this.injector = injector;
+        this.el = el;
+    }
+    onChange = () => { };
+    onTouched = () => { };
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    writeValue(value) {
+        this.el.nativeElement.value = value;
+        this.updateValidation();
+    }
+    /**
+     * Notifies the ControlValueAccessor of a change in the value of the control.
+     *
+     * This is called by each of the ValueAccessor directives when we want to update
+     * the status and validity of the form control. For example with text components this
+     * is called when the input event is fired. For select components this is called
+     * when the change event is fired.
+     *
+     * This also updates the form status on the element by setting the 'invalid' property to true/false.
+     *
+     * @param el The component element.
+     * @param value The new value of the control.
+     */
+    handleValueChange(el, value) {
+        if (el === this.el.nativeElement) {
+            this.onChange(value);
+            this.updateValidation();
+        }
+    }
+    _handleBlurEvent(el) {
+        if (el === this.el.nativeElement) {
+            this.onTouched();
+            this.updateValidation();
+        }
+    }
+    updateValidation() {
+        nextTick(() => {
+            if (this.ngControl?.control == null)
+                return;
+            const element = this.el.nativeElement;
+            const control = this.ngControl?.control;
+            const invalid = control.status === 'INVALID' && control.dirty && control.touched;
+            element.invalid = invalid;
+            // If the module is configured to do so, display error messages for invalid controls
+            if (!this.config.disableValidationService) {
+                const errorTexts = invalid ? this.initialErrorText || this.getErrorTexts(control) : undefined;
+                element.errorText = errorTexts ?? '';
+            }
+            // When the module is configured to do so, display an asterisk next to any form control that has a required validator
+            if (this.config.showAsteriskOnRequiredValidator && this.ngControl.control.hasValidator(Validators.required)) {
+                element.required = true;
+            }
+        });
+    }
+    setDisabledState(isDisabled) {
+        this.el.nativeElement.disabled = isDisabled;
+    }
+    ngOnDestroy() {
+        if (this.statusChanges) {
+            this.statusChanges.unsubscribe();
+        }
+    }
+    ngAfterViewInit() {
+        this.initialErrorText = this.el.nativeElement?.errorText?.trim() || undefined;
+        try {
+            this.ngControl = this.injector.get(NgControl);
+        }
+        catch {
+            /* No FormControl or ngModel binding */
+        }
+        if (!this.ngControl) {
+            return;
+        }
+        // Listen for changes in validity, disabled, or pending states
+        if (this.ngControl.statusChanges) {
+            this.statusChanges = this.ngControl.statusChanges.subscribe(() => this.updateValidation());
+        }
+        /**
+         * TODO FW-2787: Remove this in favor of https://github.com/angular/angular/issues/10887
+         * whenever it is implemented.
+         */
+        const formControl = this.ngControl.control;
+        if (formControl) {
+            const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine'];
+            methodsToPatch.forEach((method) => {
+                if (typeof formControl[method] !== 'undefined') {
+                    const oldFn = formControl[method].bind(formControl);
+                    formControl[method] = (...params) => {
+                        oldFn(...params);
+                        this.updateValidation();
+                    };
+                }
+            });
+        }
+    }
+    getErrorTexts(control) {
+        if (control.errors == null) {
+            console.warn('no errors for invalid control', control);
+            return [];
+        }
+        const errorList = Object.entries(control.errors);
+        if (errorList.length <= 0) {
+            console.warn('no errors for invalid control', control);
+            return [];
+        }
+        return errorList.map((error) => {
+            const [key, value] = error;
+            return (this.validationMessagesService.getErrorMessage(getLanguage(), { key: key, ...value }) ?? key);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: ValueAccessor, isStandalone: true, host: { listeners: { "blur": "_handleBlurEvent($event.target)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ValueAccessor, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { _handleBlurEvent: [{
+                type: HostListener,
+                args: ['blur', ['$event.target']]
+            }] } });
+const nextTick = (h) => {
+    if (typeof __zone_symbol__requestAnimationFrame === 'function') {
+        return __zone_symbol__requestAnimationFrame(h);
+    }
+    if (typeof requestAnimationFrame === 'function') {
+        return requestAnimationFrame(h);
+    }
+    return setTimeout(h);
+};
+
+class TextValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleInputEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: TextValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: TextValueAccessor, isStandalone: false, selector: "six-input:not([type=number]),six-textarea", host: { listeners: { "input": "handleInputEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: TextValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: TextValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-input:not([type=number]),six-textarea',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: TextValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleInputEvent: [{
+                type: HostListener,
+                args: ['input', ['$event.target']]
+            }] } });
+
+class NumericValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleInputEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    registerOnChange(fn) {
+        super.registerOnChange((value) => {
+            fn(value === '' ? null : parseFloat(value));
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NumericValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: NumericValueAccessor, isStandalone: false, selector: "six-input[type=number]", host: { listeners: { "input": "handleInputEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: NumericValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NumericValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-input[type=number]',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: NumericValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleInputEvent: [{
+                type: HostListener,
+                args: ['input', ['$event.target']]
+            }] } });
+
+class RadioValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    value;
+    formControlName;
+    name;
+    handleChangeEvent(el) {
+        if (el) {
+            this.handleValueChange(el, this.value);
+        }
+    }
+    ngOnInit() {
+        this.checkName();
+    }
+    writeValue(value) {
+        this.el.nativeElement.checked = value === this.value;
+        this.updateValidation();
+    }
+    checkName() {
+        if (this.name && this.formControlName && this.name !== this.formControlName) {
+            throw new Error(`
+      If you define both a name and a formControlName attribute on your radio button, their values
+      must match. Ex: <six-input type="radio" formControlName="food" name="food">
+    `);
+        }
+        if (!this.name && this.formControlName) {
+            this.name = this.formControlName;
+            this.el.nativeElement.name = this.formControlName;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: RadioValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: RadioValueAccessor, isStandalone: false, selector: "six-radio", inputs: { value: "value", formControlName: "formControlName", name: "name" }, host: { listeners: { "change": "handleChangeEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: RadioValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: RadioValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-radio',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: RadioValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { value: [{
+                type: Input
+            }], formControlName: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], handleChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+class DatepickerValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleChangeEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: DatepickerValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: DatepickerValueAccessor, isStandalone: false, selector: "six-datepicker", host: { listeners: { "change": "handleChangeEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: DatepickerValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: DatepickerValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-datepicker',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: DatepickerValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+/**
+ * This directive intercepts the ngSubmit event of an Angular form and introduces
+ * a supplementary event named sixSubmit. The sixSubmit event is triggered exclusively
+ * when the form is valid. In cases where the form is considered invalid, this directive
+ * takes proactive actions by marking all form controls as touched and dirty. Additionally,
+ * it shifts the focus to the initial invalid form element, facilitating quick error
+ * resolution.
+ *
+ * To utilize this directive, apply it to an Angular form.
+ * ```html
+ * <form [formGroup]="form" sixForm (sixSubmit)="onSubmit($event)">
+ *   <!-- form content -->
+ * </form>
+ * ```
+ *
+ * For users needing greater flexibility in determining when error messages are displayed,
+ * or for those who prefer not to rely solely on the form submission event,
+ * an alternative is to use the SixFormUtilDirective.
+ */
+class SixFormDirective {
+    elementRef;
+    formGroupDirective;
+    /**
+     * Emits an event when the form is valid and the form submission has been triggered.
+     */
+    sixSubmit = new EventEmitter();
+    onNgSubmit(event) {
+        if (this.formGroupDirective.invalid) {
+            focusInvalidField(this.formGroupDirective, this.elementRef);
+        }
+        else {
+            this.sixSubmit.emit(event);
+        }
+    }
+    constructor(elementRef, formGroupDirective) {
+        this.elementRef = elementRef;
+        this.formGroupDirective = formGroupDirective;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFormDirective, deps: [{ token: i0.ElementRef }, { token: i1.FormGroupDirective }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SixFormDirective, isStandalone: false, selector: "form[sixForm]", outputs: { sixSubmit: "sixSubmit" }, host: { listeners: { "ngSubmit": "onNgSubmit($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFormDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'form[sixForm]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.FormGroupDirective }], propDecorators: { sixSubmit: [{
+                type: Output
+            }], onNgSubmit: [{
+                type: HostListener,
+                args: ['ngSubmit', ['$event']]
+            }] } });
+/**
+ * This directive provides a utility method, that marks all form controls
+ * as touched and dirty, and focuses the first invalid form element.
+ *
+ * To utilize this directive, apply it to an Angular form.
+ * ```html
+ * <form [formGroup]="form" sixFormUtil (ngSubmit)="onSubmit($event)">
+ *   <!-- form content -->
+ * </form>
+ * ```
+ *
+ * Then, get a reference to the directive and invoke `focusInvalidField()` if the
+ * form is invalid:
+ * ```ts
+ * @ViewChild(SixFormUtilDirective) sixFormUtil!: SixFormUtilDirective;
+ * // ...
+ * onSubmit() {
+ *   if (this.form.invalid) {
+ *     this.sixFormUtil.focusInvalidField();
+ *   } else {
+ *      // ...
+ *   }
+ * }
+ * ```
+ */
+class SixFormUtilDirective {
+    elementRef;
+    formGroupDirective;
+    constructor(elementRef, formGroupDirective) {
+        this.elementRef = elementRef;
+        this.formGroupDirective = formGroupDirective;
+    }
+    /** markAllControlsAsDirty(Object.values(formGroup.controls));
+     * Marks all form controls as touched and dirty, and focuses the first
+     * invalid form element.
+     */
+    focusInvalidField() {
+        focusInvalidField(this.formGroupDirective, this.elementRef);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFormUtilDirective, deps: [{ token: i0.ElementRef }, { token: i1.FormGroupDirective }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SixFormUtilDirective, isStandalone: false, selector: "[sixFormUtil]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixFormUtilDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sixFormUtil]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.FormGroupDirective }] });
+function focusInvalidField(formGroupDirective, formElement) {
+    formGroupDirective.form.markAllAsTouched();
+    markAllAsDirty([formGroupDirective.form]);
+    const invalidElement = getInvalidElement(formElement.nativeElement);
+    if ('setFocus' in invalidElement && typeof invalidElement?.setFocus === 'function') {
+        invalidElement.setFocus();
+    }
+    if ('focus' in invalidElement && typeof invalidElement?.focus === 'function') {
+        invalidElement.focus();
+    }
+}
+function getInvalidElement(parent) {
+    const invalidElement = parent.querySelector('.ng-invalid');
+    if (invalidElement == null) {
+        return parent;
+    }
+    return getInvalidElement(invalidElement);
+}
+function markAllAsDirty(controls) {
+    controls.forEach((control) => {
+        if (control instanceof FormControl) {
+            control.markAsDirty({ onlySelf: true });
+        }
+        else if (control instanceof FormGroup) {
+            control.markAsDirty({ onlySelf: true });
+            markAllAsDirty(Object.values(control.controls));
+        }
+        else if (control instanceof FormArray) {
+            control.markAsDirty({ onlySelf: true });
+            markAllAsDirty(control.controls);
+        }
+    });
+}
+
+class SixUiLibraryValidators {
+    static minDate(mindate) {
+        return (control) => {
+            if (control.value == null)
+                return null;
+            const actualDate = control.value;
+            return actualDate.getTime() >= mindate.getTime() ? null : { mindate: { mindate, actual: actualDate } };
+        };
+    }
+    static maxDate(maxdate) {
+        return (control) => {
+            if (control.value == null)
+                return null;
+            const actualDate = control.value;
+            return actualDate.getTime() <= maxdate.getTime() ? null : { maxdate: { maxdate, actual: actualDate } };
+        };
+    }
+    static allowedDates(allowedDates = () => true) {
+        return (control) => {
+            if (control.value == null)
+                return null;
+            const allowed = allowedDates(control.value);
+            return allowed ? null : { invaliddate: { actual: control.value } };
+        };
+    }
+    static minDateIso(mindate) {
+        return (control) => {
+            if (control.value == null || control.value === '')
+                return null;
+            const actualDate = control.value;
+            return actualDate >= mindate ? null : { mindate: { mindate, actual: actualDate } };
+        };
+    }
+    static maxDateIso(maxdate) {
+        return (control) => {
+            if (control.value == null || control.value === '')
+                return null;
+            const actualDate = control.value;
+            return actualDate <= maxdate ? null : { maxdate: { maxdate, actual: actualDate } };
+        };
+    }
+    static allowedDatesIso(allowedDates = () => true) {
+        return (control) => {
+            if (control.value == null || control.value === '')
+                return null;
+            const allowed = allowedDates(control.value);
+            return allowed ? null : { invaliddate: { actual: control.value } };
+        };
+    }
+}
+class MinDateValidator {
+    min;
+    validate(control) {
+        if (this.min != null) {
+            return SixUiLibraryValidators.minDate(this.min)(control);
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MinDateValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: MinDateValidator, isStandalone: false, selector: "six-datepicker[min]", inputs: { min: "min" }, providers: [{ provide: NG_VALIDATORS, useExisting: MinDateValidator, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MinDateValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-datepicker[min]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MinDateValidator, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { min: [{
+                type: Input
+            }] } });
+class MaxDateValidator {
+    max;
+    validate(control) {
+        if (this.max != null) {
+            return SixUiLibraryValidators.maxDate(this.max)(control);
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MaxDateValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: MaxDateValidator, isStandalone: false, selector: "six-datepicker[max]", inputs: { max: "max" }, providers: [{ provide: NG_VALIDATORS, useExisting: MaxDateValidator, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MaxDateValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-datepicker[max]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MaxDateValidator, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { max: [{
+                type: Input
+            }] } });
+class AllowedDatesValidator {
+    allowedDates = () => true;
+    validate(control) {
+        return SixUiLibraryValidators.allowedDates(this.allowedDates)(control);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AllowedDatesValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: AllowedDatesValidator, isStandalone: false, selector: "six-datepicker[allowedDates]", inputs: { allowedDates: "allowedDates" }, providers: [{ provide: NG_VALIDATORS, useExisting: AllowedDatesValidator, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AllowedDatesValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-datepicker[allowedDates]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AllowedDatesValidator, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { allowedDates: [{
+                type: Input
+            }] } });
+class MinDateValidatorIso {
+    min;
+    validate(control) {
+        if (this.min != null) {
+            return SixUiLibraryValidators.minDateIso(this.min)(control);
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MinDateValidatorIso, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: MinDateValidatorIso, isStandalone: false, selector: "six-date[min]", inputs: { min: "min" }, providers: [{ provide: NG_VALIDATORS, useExisting: MinDateValidatorIso, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MinDateValidatorIso, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-date[min]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MinDateValidatorIso, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { min: [{
+                type: Input
+            }] } });
+class MaxDateValidatorIso {
+    max;
+    validate(control) {
+        if (this.max != null) {
+            return SixUiLibraryValidators.maxDateIso(this.max)(control);
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MaxDateValidatorIso, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: MaxDateValidatorIso, isStandalone: false, selector: "six-date[max]", inputs: { max: "max" }, providers: [{ provide: NG_VALIDATORS, useExisting: MaxDateValidatorIso, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MaxDateValidatorIso, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-date[max]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MaxDateValidatorIso, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { max: [{
+                type: Input
+            }] } });
+class AllowedDatesValidatorIso {
+    allowedDates = () => true;
+    validate(control) {
+        return SixUiLibraryValidators.allowedDatesIso(this.allowedDates)(control);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AllowedDatesValidatorIso, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: AllowedDatesValidatorIso, isStandalone: false, selector: "six-date[allowedDates]", inputs: { allowedDates: "allowedDates" }, providers: [{ provide: NG_VALIDATORS, useExisting: AllowedDatesValidatorIso, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AllowedDatesValidatorIso, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-date[allowedDates]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AllowedDatesValidatorIso, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { allowedDates: [{
+                type: Input
+            }] } });
+class MinValidator {
+    min;
+    validate(control) {
+        return Validators.min(toFloat(this.min))(control);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MinValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: MinValidator, isStandalone: false, selector: "six-input[type=number][min]", inputs: { min: "min" }, providers: [{ provide: NG_VALIDATORS, useExisting: MinValidator, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MinValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-input[type=number][min]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MinValidator, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { min: [{
+                type: Input
+            }] } });
+class MaxValidator {
+    max;
+    validate(control) {
+        return Validators.max(toFloat(this.max))(control);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MaxValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: MaxValidator, isStandalone: false, selector: "six-input[type=number][max]", inputs: { max: "max" }, providers: [{ provide: NG_VALIDATORS, useExisting: MaxValidator, multi: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: MaxValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-input[type=number][max]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MaxValidator, multi: true }],
+                    standalone: false,
+                }]
+        }], propDecorators: { max: [{
+                type: Input
+            }] } });
+function toFloat(value) {
+    return typeof value === 'number' ? value : parseFloat(value);
+}
+
+class SelectValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleChangeEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SelectValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SelectValueAccessor, isStandalone: false, selector: "six-select", host: { listeners: { "change": "handleChangeEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: SelectValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SelectValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-select',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: SelectValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+class CheckboxValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleChangeEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.checked);
+        }
+    }
+    writeValue(value) {
+        this.el.nativeElement.checked = value === true;
+        this.updateValidation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: CheckboxValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: CheckboxValueAccessor, isStandalone: false, selector: "six-checkbox:not([six-checkbox-group])", host: { listeners: { "change": "handleChangeEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: CheckboxValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: CheckboxValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-checkbox:not([six-checkbox-group])',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: CheckboxValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+class SixCheckboxGroupDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixCheckboxGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SixCheckboxGroupDirective, isStandalone: false, selector: "[six-checkbox-group]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixCheckboxGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[six-checkbox-group]',
+                    standalone: false,
+                }]
+        }] });
+// Accessor applies only when the SixCheckboxGroupDirective attribute is present
+class CheckboxMultiSelectValueAccessor extends ValueAccessor {
+    value;
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    onHostChange(el) {
+        if (!el)
+            return;
+        const checkbox = el;
+        const checked = checkbox.checked;
+        const current = this.ngControl?.value;
+        if (!current)
+            return;
+        const set = new Set(current);
+        checked ? set.add(this.value) : set.delete(this.value);
+        this.handleValueChange(el, Array.from(set));
+    }
+    writeValue(values) {
+        const arr = Array.isArray(values) ? values : [];
+        const checkbox = this.el.nativeElement;
+        checkbox.checked = arr.includes(this.value);
+        this.updateValidation();
+    }
+    setDisabledState(isDisabled) {
+        this.el.nativeElement.disabled = isDisabled;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: CheckboxMultiSelectValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: CheckboxMultiSelectValueAccessor, isStandalone: false, selector: "six-checkbox[six-checkbox-group]", inputs: { value: "value" }, host: { listeners: { "change": "onHostChange($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: CheckboxMultiSelectValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: CheckboxMultiSelectValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-checkbox[six-checkbox-group]',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: CheckboxMultiSelectValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { value: [{
+                type: Input,
+                args: [{ required: true }]
+            }], onHostChange: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+class RangeValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleInputEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    registerOnChange(fn) {
+        super.registerOnChange((value) => {
+            fn(value === '' ? null : parseFloat(value));
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: RangeValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: RangeValueAccessor, isStandalone: false, selector: "six-range", host: { listeners: { "input": "handleInputEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: RangeValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: RangeValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-range',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: RangeValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleInputEvent: [{
+                type: HostListener,
+                args: ['input', ['$event.target']]
+            }] } });
+
+class SwitchValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleChangeEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.checked);
+        }
+    }
+    writeValue(value) {
+        this.el.nativeElement.checked = value === true;
+        this.updateValidation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SwitchValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SwitchValueAccessor, isStandalone: false, selector: "six-switch", host: { listeners: { "change": "handleChangeEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: SwitchValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SwitchValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-switch',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: SwitchValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+class TimepickerValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleChangeEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: TimepickerValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: TimepickerValueAccessor, isStandalone: false, selector: "six-timepicker", host: { listeners: { "change": "handleChangeEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: TimepickerValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: TimepickerValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-timepicker',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: TimepickerValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+/**
+ * Forked from  https://github.com/ionic-team/ionic-framework/blob/main/packages/angular/common/src/directives/navigation/router-link-delegate.ts.
+ */
+class SixRouterLinkDirective {
+    locationStrategy;
+    elementRef;
+    router;
+    renderer;
+    routerLinkDirective;
+    constructor(locationStrategy, elementRef, router, renderer, routerLinkDirective) {
+        this.locationStrategy = locationStrategy;
+        this.elementRef = elementRef;
+        this.router = router;
+        this.renderer = renderer;
+        this.routerLinkDirective = routerLinkDirective;
+    }
+    onClick(event) {
+        // Prevents the browser from performing a page reload when pressing a SIX-component with routerLink.
+        event.preventDefault();
+    }
+    routerLink;
+    queryParams;
+    fragment;
+    queryParamsHandling;
+    relativeTo;
+    ngOnInit() {
+        this.updateTargetUrlAndHref();
+    }
+    ngOnChanges() {
+        this.updateTargetUrlAndHref();
+    }
+    updateTargetUrlAndHref() {
+        if (this.routerLinkDirective?.urlTree) {
+            const url = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLinkDirective.urlTree));
+            this.renderer.setAttribute(this.elementRef.nativeElement, 'href', url);
+            // Remove the `tabindex` attribute to prevent redundant focus behavior.
+            // Angular's RouterLink adds `tabindex="0"` to non-focusable elements (e.g., `<div>`),
+            // but custom components like `six-button` already handle focusability.
+            // Keeping the tabindex would cause the element to receive focus twice.
+            this.renderer.removeAttribute(this.elementRef.nativeElement, 'tabindex');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRouterLinkDirective, deps: [{ token: i1$1.LocationStrategy }, { token: i0.ElementRef }, { token: i2.Router }, { token: i0.Renderer2 }, { token: i2.RouterLink, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SixRouterLinkDirective, isStandalone: false, selector: "six-sidebar-item[routerLink],six-sidebar-item-group[routerLink],six-button[routerLink],six-icon-button[routerLink]", inputs: { routerLink: "routerLink", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", relativeTo: "relativeTo" }, host: { listeners: { "click": "onClick($event)" } }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SixRouterLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-sidebar-item[routerLink],six-sidebar-item-group[routerLink],six-button[routerLink],six-icon-button[routerLink]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i1$1.LocationStrategy }, { type: i0.ElementRef }, { type: i2.Router }, { type: i0.Renderer2 }, { type: i2.RouterLink, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], routerLink: [{
+                type: Input
+            }], queryParams: [{
+                type: Input
+            }], fragment: [{
+                type: Input
+            }], queryParamsHandling: [{
+                type: Input
+            }], relativeTo: [{
+                type: Input
+            }] } });
+
+/**
+ * Enables Angular router integration for the six-sidebar component.
+ *
+ * When this directive is added to a six-sidebar component using the 'sixRouterLinkActive' attribute,
+ * it activates automatic route-based selection for sidebar items and groups.
+ *
+ * @recommended Add this directive to enable automatic route-based navigation in sidebars.
+ *
+ * @example
+ * ```html
+ * <six-sidebar sixRouterLinkActive>
+ *   <six-sidebar-item routerLink="/home">Home</six-sidebar-item>
+ *   <six-sidebar-item-group>
+ *     <six-sidebar-item routerLink="/settings/profile">Profile</six-sidebar-item>
+ *   </six-sidebar-item-group>
+ * </six-sidebar>
+ * ```
+ */
+class ActiveSidebarDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ActiveSidebarDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: ActiveSidebarDirective, isStandalone: false, selector: "six-sidebar[sixRouterLinkActive]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ActiveSidebarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-sidebar[sixRouterLinkActive]',
+                    standalone: false,
+                }]
+        }] });
+/**
+ * Enhances six-sidebar-item with Angular router integration.
+ *
+ * This directive automatically manages the 'selected' state of sidebar items based on the current route.
+ * When used with ActiveSidebarDirective, it switches from manual selection to route-based selection.
+ *
+ * @requires RouterLinkActive
+ * @optional ActiveSidebarDirective - If present, enables route-based selection
+ */
+class ActiveSidebarItemDirective {
+    routerLinkActive = inject(RouterLinkActive);
+    sidebarItem = inject(SixSidebarItem);
+    activeSidebarDirective = inject(ActiveSidebarDirective, { optional: true });
+    get selected() {
+        if (this.activeSidebarDirective == null) {
+            return this.sidebarItem.selected;
+        }
+        else {
+            return this.routerLinkActive.isActive;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ActiveSidebarItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: ActiveSidebarItemDirective, isStandalone: false, selector: "six-sidebar-item", host: { properties: { "selected": "this.selected" } }, hostDirectives: [{ directive: i2.RouterLinkActive }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ActiveSidebarItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-sidebar-item',
+                    hostDirectives: [RouterLinkActive],
+                    standalone: false,
+                }]
+        }], propDecorators: { selected: [{
+                type: HostBinding,
+                args: ['selected']
+            }] } });
+/**
+ * Enhances six-sidebar-item-group with Angular router integration.
+ *
+ * This directive automatically manages the 'open' state of sidebar groups based on the active route.
+ * When a child route is active, the group automatically expands to show the active item.
+ *
+ * @requires RouterLinkActive
+ * @optional ActiveSidebarDirective - If present, enables route-based expansion
+ */
+class ActiveSidebarItemGroupDirective {
+    routerLinkActive = inject(RouterLinkActive);
+    sidebarItemGroup = inject(SixSidebarItemGroup);
+    activeSidebarDirective = inject(ActiveSidebarDirective, { optional: true });
+    sidebarItems;
+    get open() {
+        if (this.activeSidebarDirective == null) {
+            return this.sidebarItemGroup.open;
+        }
+        if (this.sidebarItems?.length > 0) {
+            return this.routerLinkActive.isActive ? true : this.sidebarItemGroup.open;
+        }
+        return this.routerLinkActive.isActive;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ActiveSidebarItemGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: ActiveSidebarItemGroupDirective, isStandalone: false, selector: "six-sidebar-item-group", host: { properties: { "open": "this.open" } }, queries: [{ propertyName: "sidebarItems", predicate: SixSidebarItem }], hostDirectives: [{ directive: i2.RouterLinkActive }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: ActiveSidebarItemGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-sidebar-item-group',
+                    hostDirectives: [RouterLinkActive],
+                    standalone: false,
+                }]
+        }], propDecorators: { sidebarItems: [{
+                type: ContentChildren,
+                args: [SixSidebarItem]
+            }], open: [{
+                type: HostBinding,
+                args: ['open']
+            }] } });
+
+class DateValueAccessor extends ValueAccessor {
+    constructor(injector, el) {
+        super(injector, el);
+    }
+    handleInputEvent(el) {
+        if (el) {
+            this.handleValueChange(el, el.value);
+        }
+    }
+    writeValue(value) {
+        this.el.nativeElement.value = value == null ? '' : value;
+        this.updateValidation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: DateValueAccessor, deps: [{ token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: DateValueAccessor, isStandalone: false, selector: "six-date", host: { listeners: { "change": "handleInputEvent($event.target)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: DateValueAccessor,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: DateValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'six-date',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: DateValueAccessor,
+                            multi: true,
+                        },
+                    ],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { handleInputEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }] } });
+
+/**
+ * Custom elements are registered in the global `customElements` registry, so registering them
+ * more than once is pointless and expensive. `forRoot()` may be called once per injector
+ * (e.g. once per test case), therefore the registration is memoized per JS realm.
+ */
+let customElementsRegistration;
+const registerCustomElementsOnce = () => {
+    customElementsRegistration ??= (async () => {
+        defineCustomElements();
+    })();
+    return customElementsRegistration;
+};
+class UiLibraryAngularModule {
+    static forRoot(customValidationMessagesService, config) {
+        const mergedConfig = {
+            ...DEFAULT_UI_LIBRARY_CONFIG,
+            ...config,
+        };
+        return {
+            ngModule: UiLibraryAngularModule,
+            providers: [
+                provideAppInitializer(() => registerCustomElementsOnce()),
+                { provide: ValidationMessagesService, useClass: customValidationMessagesService ?? ValidationMessagesService },
+                { provide: UI_LIBRARY_CONFIG, useValue: mergedConfig },
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: UiLibraryAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.17", ngImport: i0, type: UiLibraryAngularModule, declarations: [SixAlert, SixAvatar, SixBadge, SixBreadcrumbs, SixBreadcrumbsItem, SixButton, SixCard, SixCheckbox, SixDate, SixDatepicker, SixDetails, SixDialog, SixDrawer, SixDropdown, SixError, SixErrorPage, SixFileList, SixFileListItem, SixFileUpload, SixFooter, SixGroupLabel, SixHeader, SixHeaderDropdownItem, SixHeaderItem, SixHeaderMenuButton, SixIcon, SixIconButton, SixInput, SixItemPicker, SixLanguageSwitcher, SixLayoutGrid, SixLogo, SixMainContainer, SixMenu, SixMenuDivider, SixMenuItem, SixMenuLabel, SixPaginator, SixPicto, SixProgressBar, SixProgressRing, SixRadio, SixRange, SixRating, SixRoot, SixSearchField, SixSelect, SixSidebar, SixSidebarItem, SixSidebarItemGroup, SixSpinner, SixStageIndicator, SixSwitch, SixTab, SixTabGroup, SixTabPanel, SixTag, SixTextarea, SixTile, SixTimepicker, SixTooltip, 
+            // value accessors
+            TextValueAccessor,
+            NumericValueAccessor,
+            RadioValueAccessor,
+            DatepickerValueAccessor,
+            DateValueAccessor,
+            TimepickerValueAccessor,
+            SelectValueAccessor,
+            CheckboxValueAccessor,
+            CheckboxMultiSelectValueAccessor,
+            SixCheckboxGroupDirective,
+            SwitchValueAccessor,
+            RangeValueAccessor,
+            // validators
+            MinValidator,
+            MaxValidator,
+            MinDateValidator,
+            MaxDateValidator,
+            AllowedDatesValidator,
+            MinDateValidatorIso,
+            MaxDateValidatorIso,
+            AllowedDatesValidatorIso,
+            // form helpers
+            SixFormDirective,
+            SixFormUtilDirective,
+            // router link directive
+            SixRouterLinkDirective,
+            // sidebar helpers
+            ActiveSidebarItemDirective,
+            ActiveSidebarItemGroupDirective,
+            ActiveSidebarDirective], exports: [SixAlert, SixAvatar, SixBadge, SixBreadcrumbs, SixBreadcrumbsItem, SixButton, SixCard, SixCheckbox, SixDate, SixDatepicker, SixDetails, SixDialog, SixDrawer, SixDropdown, SixError, SixErrorPage, SixFileList, SixFileListItem, SixFileUpload, SixFooter, SixGroupLabel, SixHeader, SixHeaderDropdownItem, SixHeaderItem, SixHeaderMenuButton, SixIcon, SixIconButton, SixInput, SixItemPicker, SixLanguageSwitcher, SixLayoutGrid, SixLogo, SixMainContainer, SixMenu, SixMenuDivider, SixMenuItem, SixMenuLabel, SixPaginator, SixPicto, SixProgressBar, SixProgressRing, SixRadio, SixRange, SixRating, SixRoot, SixSearchField, SixSelect, SixSidebar, SixSidebarItem, SixSidebarItemGroup, SixSpinner, SixStageIndicator, SixSwitch, SixTab, SixTabGroup, SixTabPanel, SixTag, SixTextarea, SixTile, SixTimepicker, SixTooltip, 
+            // value accessors
+            TextValueAccessor,
+            NumericValueAccessor,
+            RadioValueAccessor,
+            DatepickerValueAccessor,
+            DateValueAccessor,
+            TimepickerValueAccessor,
+            SelectValueAccessor,
+            CheckboxValueAccessor,
+            CheckboxMultiSelectValueAccessor,
+            SixCheckboxGroupDirective,
+            SwitchValueAccessor,
+            RangeValueAccessor,
+            // validators
+            MinValidator,
+            MaxValidator,
+            MinDateValidator,
+            MaxDateValidator,
+            AllowedDatesValidator,
+            MinDateValidatorIso,
+            MaxDateValidatorIso,
+            AllowedDatesValidatorIso,
+            // form helpers
+            SixFormDirective,
+            SixFormUtilDirective,
+            // router link directive
+            SixRouterLinkDirective,
+            // sidebar helpers
+            ActiveSidebarItemDirective,
+            ActiveSidebarItemGroupDirective,
+            ActiveSidebarDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: UiLibraryAngularModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: UiLibraryAngularModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        // proxies
+                        ...DIRECTIVES,
+                        // value accessors
+                        TextValueAccessor,
+                        NumericValueAccessor,
+                        RadioValueAccessor,
+                        DatepickerValueAccessor,
+                        DateValueAccessor,
+                        TimepickerValueAccessor,
+                        SelectValueAccessor,
+                        CheckboxValueAccessor,
+                        CheckboxMultiSelectValueAccessor,
+                        SixCheckboxGroupDirective,
+                        SwitchValueAccessor,
+                        RangeValueAccessor,
+                        // validators
+                        MinValidator,
+                        MaxValidator,
+                        MinDateValidator,
+                        MaxDateValidator,
+                        AllowedDatesValidator,
+                        MinDateValidatorIso,
+                        MaxDateValidatorIso,
+                        AllowedDatesValidatorIso,
+                        // form helpers
+                        SixFormDirective,
+                        SixFormUtilDirective,
+                        // router link directive
+                        SixRouterLinkDirective,
+                        // sidebar helpers
+                        ActiveSidebarItemDirective,
+                        ActiveSidebarItemGroupDirective,
+                        ActiveSidebarDirective,
+                    ],
+                    imports: [],
+                    exports: [
+                        // proxies
+                        ...DIRECTIVES,
+                        // value accessors
+                        TextValueAccessor,
+                        NumericValueAccessor,
+                        RadioValueAccessor,
+                        DatepickerValueAccessor,
+                        DateValueAccessor,
+                        TimepickerValueAccessor,
+                        SelectValueAccessor,
+                        CheckboxValueAccessor,
+                        CheckboxMultiSelectValueAccessor,
+                        SixCheckboxGroupDirective,
+                        SwitchValueAccessor,
+                        RangeValueAccessor,
+                        // validators
+                        MinValidator,
+                        MaxValidator,
+                        MinDateValidator,
+                        MaxDateValidator,
+                        AllowedDatesValidator,
+                        MinDateValidatorIso,
+                        MaxDateValidatorIso,
+                        AllowedDatesValidatorIso,
+                        // form helpers
+                        SixFormDirective,
+                        SixFormUtilDirective,
+                        // router link directive
+                        SixRouterLinkDirective,
+                        // sidebar helpers
+                        ActiveSidebarItemDirective,
+                        ActiveSidebarItemGroupDirective,
+                        ActiveSidebarDirective,
+                    ],
+                }]
+        }] });
+
+class AlertService {
+    ngZone = inject(NgZone);
+    /**
+     * Displays an alert as a toast notification.
+     */
+    showAlert(message, alertType, duration, iconName) {
+        this.ngZone.runOutsideAngular(() => showAlert(message, alertType, duration, iconName));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AlertService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AlertService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: AlertService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/*
+ * Public API Surface of ui-library-angular
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActiveSidebarDirective, ActiveSidebarItemDirective, ActiveSidebarItemGroupDirective, AlertService, AllowedDatesValidator, AllowedDatesValidatorIso, CheckboxMultiSelectValueAccessor, CheckboxValueAccessor, DEFAULT_UI_LIBRARY_CONFIG, DIRECTIVES, DateValueAccessor, DatepickerValueAccessor, MaxDateValidator, MaxDateValidatorIso, MaxValidator, MinDateValidator, MinDateValidatorIso, MinValidator, NumericValueAccessor, RadioValueAccessor, RangeValueAccessor, SelectValueAccessor, SixAlert, SixAvatar, SixBadge, SixBreadcrumbs, SixBreadcrumbsItem, SixButton, SixCard, SixCheckbox, SixCheckboxGroupDirective, SixDate, SixDatepicker, SixDetails, SixDialog, SixDrawer, SixDropdown, SixError, SixErrorPage, SixFileList, SixFileListItem, SixFileUpload, SixFooter, SixFormDirective, SixFormUtilDirective, SixGroupLabel, SixHeader, SixHeaderDropdownItem, SixHeaderItem, SixHeaderMenuButton, SixIcon, SixIconButton, SixInput, SixItemPicker, SixLanguageSwitcher, SixLayoutGrid, SixLogo, SixMainContainer, SixMenu, SixMenuDivider, SixMenuItem, SixMenuLabel, SixPaginator, SixPicto, SixProgressBar, SixProgressRing, SixRadio, SixRange, SixRating, SixRoot, SixRouterLinkDirective, SixSearchField, SixSelect, SixSidebar, SixSidebarItem, SixSidebarItemGroup, SixSpinner, SixStageIndicator, SixSwitch, SixTab, SixTabGroup, SixTabPanel, SixTag, SixTextarea, SixTile, SixTimepicker, SixTooltip, SixUiLibraryValidators, SwitchValueAccessor, TextValueAccessor, TimepickerValueAccessor, UI_LIBRARY_CONFIG, UiLibraryAngularModule, ValidationMessagesService, ValueAccessor };
+//# sourceMappingURL=six-group-ui-library-angular.mjs.map