@tessera-ui/angular 0.4.0

package/dist/directives/proxies.js

@@ -0,0 +1,1418 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/* tslint:disable */
+/* auto-generated angular directive proxies */
+import { ChangeDetectionStrategy, Component, EventEmitter, Output } from '@angular/core';
+import { ProxyCmp } from './angular-component-lib/utils';
+let TsAccordion = class TsAccordion {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsAccordion = __decorate([
+    ProxyCmp({
+        inputs: ['multiple']
+    }),
+    Component({
+        selector: 'ts-accordion',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['multiple'],
+        standalone: false
+    })
+], TsAccordion);
+export { TsAccordion };
+let TsAccordionItem = class TsAccordionItem {
+    z;
+    el;
+    tsToggle = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsAccordionItem.prototype, "tsToggle", void 0);
+TsAccordionItem = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'heading', 'open']
+    }),
+    Component({
+        selector: 'ts-accordion-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'heading', 'open'],
+        outputs: ['tsToggle'],
+        standalone: false
+    })
+], TsAccordionItem);
+export { TsAccordionItem };
+let TsAlert = class TsAlert {
+    z;
+    el;
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsAlert.prototype, "tsClose", void 0);
+TsAlert = __decorate([
+    ProxyCmp({
+        inputs: ['closable', 'variant'],
+        methods: ['close', 'show']
+    }),
+    Component({
+        selector: 'ts-alert',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['closable', 'variant'],
+        outputs: ['tsClose'],
+        standalone: false
+    })
+], TsAlert);
+export { TsAlert };
+let TsAvatar = class TsAvatar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsAvatar = __decorate([
+    ProxyCmp({
+        inputs: ['alt', 'color', 'name', 'size', 'src', 'variant']
+    }),
+    Component({
+        selector: 'ts-avatar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['alt', 'color', 'name', 'size', 'src', 'variant'],
+        standalone: false
+    })
+], TsAvatar);
+export { TsAvatar };
+let TsBadge = class TsBadge {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsBadge = __decorate([
+    ProxyCmp({
+        inputs: ['dot', 'outline', 'pill', 'size', 'variant']
+    }),
+    Component({
+        selector: 'ts-badge',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['dot', 'outline', 'pill', 'size', 'variant'],
+        standalone: false
+    })
+], TsBadge);
+export { TsBadge };
+let TsBanner = class TsBanner {
+    z;
+    el;
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsBanner.prototype, "tsClose", void 0);
+TsBanner = __decorate([
+    ProxyCmp({
+        inputs: ['dismissible', 'icon', 'sticky', 'variant'],
+        methods: ['close', 'show']
+    }),
+    Component({
+        selector: 'ts-banner',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['dismissible', 'icon', 'sticky', 'variant'],
+        outputs: ['tsClose'],
+        standalone: false
+    })
+], TsBanner);
+export { TsBanner };
+let TsBreadcrumb = class TsBreadcrumb {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsBreadcrumb = __decorate([
+    ProxyCmp({
+        inputs: ['separator']
+    }),
+    Component({
+        selector: 'ts-breadcrumb',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['separator'],
+        standalone: false
+    })
+], TsBreadcrumb);
+export { TsBreadcrumb };
+let TsBreadcrumbItem = class TsBreadcrumbItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsBreadcrumbItem = __decorate([
+    ProxyCmp({
+        inputs: ['current', 'href', 'separator']
+    }),
+    Component({
+        selector: 'ts-breadcrumb-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['current', 'href', 'separator'],
+        standalone: false
+    })
+], TsBreadcrumbItem);
+export { TsBreadcrumbItem };
+let TsButton = class TsButton {
+    z;
+    el;
+    tsClick = new EventEmitter();
+    tsFocus = new EventEmitter();
+    tsBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsButton.prototype, "tsClick", void 0);
+__decorate([
+    Output()
+], TsButton.prototype, "tsFocus", void 0);
+__decorate([
+    Output()
+], TsButton.prototype, "tsBlur", void 0);
+TsButton = __decorate([
+    ProxyCmp({
+        inputs: ['appearance', 'block', 'disabled', 'href', 'loading', 'size', 'target', 'type', 'variant']
+    }),
+    Component({
+        selector: 'ts-button',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['appearance', 'block', 'disabled', 'href', 'loading', 'size', 'target', 'type', 'variant'],
+        outputs: ['tsClick', 'tsFocus', 'tsBlur'],
+        standalone: false
+    })
+], TsButton);
+export { TsButton };
+let TsCard = class TsCard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsCard = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'elevation', 'interactive', 'padding']
+    }),
+    Component({
+        selector: 'ts-card',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['bordered', 'elevation', 'interactive', 'padding'],
+        standalone: false
+    })
+], TsCard);
+export { TsCard };
+let TsCheckbox = class TsCheckbox {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsCheckbox.prototype, "tsChange", void 0);
+TsCheckbox = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'disabled', 'error', 'indeterminate', 'label', 'name', 'size', 'value'],
+        methods: ['toggle']
+    }),
+    Component({
+        selector: 'ts-checkbox',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['checked', 'disabled', 'error', 'indeterminate', 'label', 'name', 'size', 'value'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsCheckbox);
+export { TsCheckbox };
+let TsChip = class TsChip {
+    z;
+    el;
+    tsRemove = new EventEmitter();
+    tsClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsChip.prototype, "tsRemove", void 0);
+__decorate([
+    Output()
+], TsChip.prototype, "tsClick", void 0);
+TsChip = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'outline', 'removable', 'selected', 'size', 'variant']
+    }),
+    Component({
+        selector: 'ts-chip',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'outline', 'removable', 'selected', 'size', 'variant'],
+        outputs: ['tsRemove', 'tsClick'],
+        standalone: false
+    })
+], TsChip);
+export { TsChip };
+let TsContainer = class TsContainer {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsContainer = __decorate([
+    ProxyCmp({
+        inputs: ['padding', 'size']
+    }),
+    Component({
+        selector: 'ts-container',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['padding', 'size'],
+        standalone: false
+    })
+], TsContainer);
+export { TsContainer };
+let TsDatePicker = class TsDatePicker {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsDatePicker.prototype, "tsChange", void 0);
+TsDatePicker = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'error', 'errorMessage', 'label', 'max', 'min', 'name', 'placeholder', 'size', 'value']
+    }),
+    Component({
+        selector: 'ts-date-picker',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'error', 'errorMessage', 'label', 'max', 'min', 'name', 'placeholder', 'size', 'value'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsDatePicker);
+export { TsDatePicker };
+let TsDialog = class TsDialog {
+    z;
+    el;
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsDialog.prototype, "tsClose", void 0);
+TsDialog = __decorate([
+    ProxyCmp({
+        inputs: ['dismissible', 'heading', 'open', 'size'],
+        methods: ['show', 'close']
+    }),
+    Component({
+        selector: 'ts-dialog',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['dismissible', 'heading', 'open', 'size'],
+        outputs: ['tsClose'],
+        standalone: false
+    })
+], TsDialog);
+export { TsDialog };
+let TsDivider = class TsDivider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsDivider = __decorate([
+    ProxyCmp({
+        inputs: ['label', 'orientation', 'variant']
+    }),
+    Component({
+        selector: 'ts-divider',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['label', 'orientation', 'variant'],
+        standalone: false
+    })
+], TsDivider);
+export { TsDivider };
+let TsDrawer = class TsDrawer {
+    z;
+    el;
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsDrawer.prototype, "tsClose", void 0);
+TsDrawer = __decorate([
+    ProxyCmp({
+        inputs: ['dismissible', 'heading', 'open', 'placement', 'size'],
+        methods: ['show', 'close']
+    }),
+    Component({
+        selector: 'ts-drawer',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['dismissible', 'heading', 'open', 'placement', 'size'],
+        outputs: ['tsClose'],
+        standalone: false
+    })
+], TsDrawer);
+export { TsDrawer };
+let TsEmptyState = class TsEmptyState {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsEmptyState = __decorate([
+    ProxyCmp({
+        inputs: ['description', 'heading', 'icon', 'size']
+    }),
+    Component({
+        selector: 'ts-empty-state',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['description', 'heading', 'icon', 'size'],
+        standalone: false
+    })
+], TsEmptyState);
+export { TsEmptyState };
+let TsFileUpload = class TsFileUpload {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsFileUpload.prototype, "tsChange", void 0);
+TsFileUpload = __decorate([
+    ProxyCmp({
+        inputs: ['accept', 'disabled', 'label', 'maxSize', 'multiple', 'name']
+    }),
+    Component({
+        selector: 'ts-file-upload',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['accept', 'disabled', 'label', 'maxSize', 'multiple', 'name'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsFileUpload);
+export { TsFileUpload };
+let TsGrid = class TsGrid {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsGrid = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'columns', 'gap', 'minColumnWidth']
+    }),
+    Component({
+        selector: 'ts-grid',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['align', 'columns', 'gap', 'minColumnWidth'],
+        standalone: false
+    })
+], TsGrid);
+export { TsGrid };
+let TsIcon = class TsIcon {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsIcon = __decorate([
+    ProxyCmp({
+        inputs: ['color', 'label', 'name', 'size', 'src']
+    }),
+    Component({
+        selector: 'ts-icon',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['color', 'label', 'name', 'size', 'src'],
+        standalone: false
+    })
+], TsIcon);
+export { TsIcon };
+let TsInput = class TsInput {
+    z;
+    el;
+    tsInput = new EventEmitter();
+    tsChange = new EventEmitter();
+    tsFocus = new EventEmitter();
+    tsBlur = new EventEmitter();
+    tsValidate = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsInput.prototype, "tsInput", void 0);
+__decorate([
+    Output()
+], TsInput.prototype, "tsChange", void 0);
+__decorate([
+    Output()
+], TsInput.prototype, "tsFocus", void 0);
+__decorate([
+    Output()
+], TsInput.prototype, "tsBlur", void 0);
+__decorate([
+    Output()
+], TsInput.prototype, "tsValidate", void 0);
+TsInput = __decorate([
+    ProxyCmp({
+        inputs: ['autocomplete', 'disabled', 'error', 'helpText', 'label', 'maxlength', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'size', 'type', 'value'],
+        methods: ['setFocus', 'selectText']
+    }),
+    Component({
+        selector: 'ts-input',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['autocomplete', 'disabled', 'error', 'helpText', 'label', 'maxlength', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'size', 'type', 'value'],
+        outputs: ['tsInput', 'tsChange', 'tsFocus', 'tsBlur', 'tsValidate'],
+        standalone: false
+    })
+], TsInput);
+export { TsInput };
+let TsMenu = class TsMenu {
+    z;
+    el;
+    tsOpen = new EventEmitter();
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsMenu.prototype, "tsOpen", void 0);
+__decorate([
+    Output()
+], TsMenu.prototype, "tsClose", void 0);
+TsMenu = __decorate([
+    ProxyCmp({
+        inputs: ['open', 'placement', 'trigger']
+    }),
+    Component({
+        selector: 'ts-menu',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['open', 'placement', 'trigger'],
+        outputs: ['tsOpen', 'tsClose'],
+        standalone: false
+    })
+], TsMenu);
+export { TsMenu };
+let TsMenuItem = class TsMenuItem {
+    z;
+    el;
+    tsSelect = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsMenuItem.prototype, "tsSelect", void 0);
+TsMenuItem = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'href', 'value'],
+        methods: ['setFocus']
+    }),
+    Component({
+        selector: 'ts-menu-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'href', 'value'],
+        outputs: ['tsSelect'],
+        standalone: false
+    })
+], TsMenuItem);
+export { TsMenuItem };
+let TsModal = class TsModal {
+    z;
+    el;
+    tsOpen = new EventEmitter();
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsModal.prototype, "tsOpen", void 0);
+__decorate([
+    Output()
+], TsModal.prototype, "tsClose", void 0);
+TsModal = __decorate([
+    ProxyCmp({
+        inputs: ['closeOnEscape', 'closeOnOverlay', 'label', 'open', 'showClose', 'size'],
+        methods: ['show', 'close']
+    }),
+    Component({
+        selector: 'ts-modal',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['closeOnEscape', 'closeOnOverlay', 'label', 'open', 'showClose', 'size'],
+        outputs: ['tsOpen', 'tsClose'],
+        standalone: false
+    })
+], TsModal);
+export { TsModal };
+let TsNav = class TsNav {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsNav = __decorate([
+    ProxyCmp({
+        inputs: ['collapsed', 'variant']
+    }),
+    Component({
+        selector: 'ts-nav',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['collapsed', 'variant'],
+        standalone: false
+    })
+], TsNav);
+export { TsNav };
+let TsNavItem = class TsNavItem {
+    z;
+    el;
+    tsSelect = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsNavItem.prototype, "tsSelect", void 0);
+TsNavItem = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'disabled', 'href', 'icon']
+    }),
+    Component({
+        selector: 'ts-nav-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['active', 'disabled', 'href', 'icon'],
+        outputs: ['tsSelect'],
+        standalone: false
+    })
+], TsNavItem);
+export { TsNavItem };
+let TsPagination = class TsPagination {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsPagination.prototype, "tsChange", void 0);
+TsPagination = __decorate([
+    ProxyCmp({
+        inputs: ['currentPage', 'pageSize', 'siblingCount', 'size', 'total']
+    }),
+    Component({
+        selector: 'ts-pagination',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['currentPage', 'pageSize', 'siblingCount', 'size', { name: 'total', required: true }],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsPagination);
+export { TsPagination };
+let TsPopover = class TsPopover {
+    z;
+    el;
+    tsOpen = new EventEmitter();
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsPopover.prototype, "tsOpen", void 0);
+__decorate([
+    Output()
+], TsPopover.prototype, "tsClose", void 0);
+TsPopover = __decorate([
+    ProxyCmp({
+        inputs: ['dismissible', 'open', 'placement', 'trigger'],
+        methods: ['show', 'hide']
+    }),
+    Component({
+        selector: 'ts-popover',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['dismissible', 'open', 'placement', 'trigger'],
+        outputs: ['tsOpen', 'tsClose'],
+        standalone: false
+    })
+], TsPopover);
+export { TsPopover };
+let TsProgress = class TsProgress {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsProgress = __decorate([
+    ProxyCmp({
+        inputs: ['indeterminate', 'label', 'max', 'showValue', 'size', 'value', 'variant']
+    }),
+    Component({
+        selector: 'ts-progress',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['indeterminate', 'label', 'max', 'showValue', 'size', 'value', 'variant'],
+        standalone: false
+    })
+], TsProgress);
+export { TsProgress };
+let TsRadio = class TsRadio {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsRadio.prototype, "tsChange", void 0);
+TsRadio = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'disabled', 'label', 'name', 'size', 'value'],
+        methods: ['select']
+    }),
+    Component({
+        selector: 'ts-radio',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['checked', 'disabled', 'label', 'name', 'size', 'value'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsRadio);
+export { TsRadio };
+let TsRow = class TsRow {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsRow = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'gap', 'justify', 'reverse', 'stackAt', 'wrap']
+    }),
+    Component({
+        selector: 'ts-row',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['align', 'gap', 'justify', 'reverse', 'stackAt', 'wrap'],
+        standalone: false
+    })
+], TsRow);
+export { TsRow };
+let TsSelect = class TsSelect {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    tsFocus = new EventEmitter();
+    tsBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsSelect.prototype, "tsChange", void 0);
+__decorate([
+    Output()
+], TsSelect.prototype, "tsFocus", void 0);
+__decorate([
+    Output()
+], TsSelect.prototype, "tsBlur", void 0);
+TsSelect = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'error', 'errorMessage', 'helpText', 'label', 'multiple', 'name', 'placeholder', 'required', 'size', 'value']
+    }),
+    Component({
+        selector: 'ts-select',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'error', 'errorMessage', 'helpText', 'label', 'multiple', 'name', 'placeholder', 'required', 'size', 'value'],
+        outputs: ['tsChange', 'tsFocus', 'tsBlur'],
+        standalone: false
+    })
+], TsSelect);
+export { TsSelect };
+let TsSkeleton = class TsSkeleton {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsSkeleton = __decorate([
+    ProxyCmp({
+        inputs: ['animation', 'height', 'lines', 'variant', 'width']
+    }),
+    Component({
+        selector: 'ts-skeleton',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['animation', 'height', 'lines', 'variant', 'width'],
+        standalone: false
+    })
+], TsSkeleton);
+export { TsSkeleton };
+let TsSlider = class TsSlider {
+    z;
+    el;
+    tsInput = new EventEmitter();
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsSlider.prototype, "tsInput", void 0);
+__decorate([
+    Output()
+], TsSlider.prototype, "tsChange", void 0);
+TsSlider = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'label', 'max', 'min', 'showValue', 'size', 'step', 'value']
+    }),
+    Component({
+        selector: 'ts-slider',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'label', 'max', 'min', 'showValue', 'size', 'step', 'value'],
+        outputs: ['tsInput', 'tsChange'],
+        standalone: false
+    })
+], TsSlider);
+export { TsSlider };
+let TsSpacer = class TsSpacer {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsSpacer = __decorate([
+    ProxyCmp({
+        inputs: ['axis', 'size']
+    }),
+    Component({
+        selector: 'ts-spacer',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['axis', 'size'],
+        standalone: false
+    })
+], TsSpacer);
+export { TsSpacer };
+let TsSpinner = class TsSpinner {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsSpinner = __decorate([
+    ProxyCmp({
+        inputs: ['color', 'label', 'size']
+    }),
+    Component({
+        selector: 'ts-spinner',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['color', 'label', 'size'],
+        standalone: false
+    })
+], TsSpinner);
+export { TsSpinner };
+let TsStack = class TsStack {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsStack = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'gap']
+    }),
+    Component({
+        selector: 'ts-stack',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['align', 'gap'],
+        standalone: false
+    })
+], TsStack);
+export { TsStack };
+let TsStep = class TsStep {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsStep = __decorate([
+    ProxyCmp({
+        inputs: ['completed', 'description', 'disabled', 'error', 'icon', 'label']
+    }),
+    Component({
+        selector: 'ts-step',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['completed', 'description', 'disabled', 'error', 'icon', 'label'],
+        standalone: false
+    })
+], TsStep);
+export { TsStep };
+let TsStepper = class TsStepper {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsStepper = __decorate([
+    ProxyCmp({
+        inputs: ['activeStep', 'linear', 'orientation']
+    }),
+    Component({
+        selector: 'ts-stepper',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['activeStep', 'linear', 'orientation'],
+        standalone: false
+    })
+], TsStepper);
+export { TsStepper };
+let TsSwitchGroup = class TsSwitchGroup {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsSwitchGroup.prototype, "tsChange", void 0);
+TsSwitchGroup = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'fullWidth', 'size', 'value']
+    }),
+    Component({
+        selector: 'ts-switch-group',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'fullWidth', 'size', 'value'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsSwitchGroup);
+export { TsSwitchGroup };
+let TsSwitchOption = class TsSwitchOption {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsSwitchOption = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'disabled', 'icon', 'value']
+    }),
+    Component({
+        selector: 'ts-switch-option',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['active', 'disabled', 'icon', 'value'],
+        standalone: false
+    })
+], TsSwitchOption);
+export { TsSwitchOption };
+let TsTabPanel = class TsTabPanel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsTabPanel = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'icon', 'tab', 'value']
+    }),
+    Component({
+        selector: 'ts-tab-panel',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'icon', { name: 'tab', required: true }, { name: 'value', required: true }],
+        standalone: false
+    })
+], TsTabPanel);
+export { TsTabPanel };
+let TsTable = class TsTable {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsTable = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'compact', 'hoverable', 'stickyHeader', 'striped']
+    }),
+    Component({
+        selector: 'ts-table',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['bordered', 'compact', 'hoverable', 'stickyHeader', 'striped'],
+        standalone: false
+    })
+], TsTable);
+export { TsTable };
+let TsTabs = class TsTabs {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsTabs.prototype, "tsChange", void 0);
+TsTabs = __decorate([
+    ProxyCmp({
+        inputs: ['size', 'value', 'variant']
+    }),
+    Component({
+        selector: 'ts-tabs',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['size', 'value', 'variant'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsTabs);
+export { TsTabs };
+let TsTextarea = class TsTextarea {
+    z;
+    el;
+    tsInput = new EventEmitter();
+    tsChange = new EventEmitter();
+    tsFocus = new EventEmitter();
+    tsBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsTextarea.prototype, "tsInput", void 0);
+__decorate([
+    Output()
+], TsTextarea.prototype, "tsChange", void 0);
+__decorate([
+    Output()
+], TsTextarea.prototype, "tsFocus", void 0);
+__decorate([
+    Output()
+], TsTextarea.prototype, "tsBlur", void 0);
+TsTextarea = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'error', 'errorMessage', 'helpText', 'label', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'resize', 'rows', 'size', 'value'],
+        methods: ['setFocus', 'selectText']
+    }),
+    Component({
+        selector: 'ts-textarea',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'error', 'errorMessage', 'helpText', 'label', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'resize', 'rows', 'size', 'value'],
+        outputs: ['tsInput', 'tsChange', 'tsFocus', 'tsBlur'],
+        standalone: false
+    })
+], TsTextarea);
+export { TsTextarea };
+let TsToast = class TsToast {
+    z;
+    el;
+    tsClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsToast.prototype, "tsClose", void 0);
+TsToast = __decorate([
+    ProxyCmp({
+        inputs: ['dismissible', 'duration', 'open', 'position', 'variant'],
+        methods: ['close', 'show']
+    }),
+    Component({
+        selector: 'ts-toast',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['dismissible', 'duration', 'open', 'position', 'variant'],
+        outputs: ['tsClose'],
+        standalone: false
+    })
+], TsToast);
+export { TsToast };
+let TsToggle = class TsToggle {
+    z;
+    el;
+    tsChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsToggle.prototype, "tsChange", void 0);
+TsToggle = __decorate([
+    ProxyCmp({
+        inputs: ['checked', 'disabled', 'name', 'size', 'value'],
+        methods: ['toggle']
+    }),
+    Component({
+        selector: 'ts-toggle',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['checked', 'disabled', 'name', 'size', 'value'],
+        outputs: ['tsChange'],
+        standalone: false
+    })
+], TsToggle);
+export { TsToggle };
+let TsToolbar = class TsToolbar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsToolbar = __decorate([
+    ProxyCmp({
+        inputs: ['size', 'variant']
+    }),
+    Component({
+        selector: 'ts-toolbar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['size', 'variant'],
+        standalone: false
+    })
+], TsToolbar);
+export { TsToolbar };
+let TsTooltip = class TsTooltip {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsTooltip = __decorate([
+    ProxyCmp({
+        inputs: ['content', 'disabled', 'hideDelay', 'placement', 'showDelay'],
+        methods: ['show', 'hide']
+    }),
+    Component({
+        selector: 'ts-tooltip',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['content', 'disabled', 'hideDelay', 'placement', 'showDelay'],
+        standalone: false
+    })
+], TsTooltip);
+export { TsTooltip };
+let TsTree = class TsTree {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+TsTree = __decorate([
+    ProxyCmp({
+        inputs: ['selectable']
+    }),
+    Component({
+        selector: 'ts-tree',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['selectable'],
+        standalone: false
+    })
+], TsTree);
+export { TsTree };
+let TsTreeItem = class TsTreeItem {
+    z;
+    el;
+    tsToggle = new EventEmitter();
+    tsSelect = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output()
+], TsTreeItem.prototype, "tsToggle", void 0);
+__decorate([
+    Output()
+], TsTreeItem.prototype, "tsSelect", void 0);
+TsTreeItem = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'expanded', 'icon', 'label', 'selected']
+    }),
+    Component({
+        selector: 'ts-tree-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+        inputs: ['disabled', 'expanded', 'icon', 'label', 'selected'],
+        outputs: ['tsToggle', 'tsSelect'],
+        standalone: false
+    })
+], TsTreeItem);
+export { TsTreeItem };