@beeq/angular 1.0.1 → 1.2.0

package/esm2022/standalone/directives/components.mjs

@@ -0,0 +1,1286 @@
+import { __decorate, __metadata } from "tslib";
+/* tslint:disable */
+/* auto-generated angular directive proxies */
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, NgZone } from '@angular/core';
+import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils';
+import { defineCustomElement as defineBqAccordion } from '@beeq/core/dist/components/bq-accordion.js';
+import { defineCustomElement as defineBqAccordionGroup } from '@beeq/core/dist/components/bq-accordion-group.js';
+import { defineCustomElement as defineBqAlert } from '@beeq/core/dist/components/bq-alert.js';
+import { defineCustomElement as defineBqAvatar } from '@beeq/core/dist/components/bq-avatar.js';
+import { defineCustomElement as defineBqBadge } from '@beeq/core/dist/components/bq-badge.js';
+import { defineCustomElement as defineBqBreadcrumb } from '@beeq/core/dist/components/bq-breadcrumb.js';
+import { defineCustomElement as defineBqBreadcrumbItem } from '@beeq/core/dist/components/bq-breadcrumb-item.js';
+import { defineCustomElement as defineBqButton } from '@beeq/core/dist/components/bq-button.js';
+import { defineCustomElement as defineBqCard } from '@beeq/core/dist/components/bq-card.js';
+import { defineCustomElement as defineBqCheckbox } from '@beeq/core/dist/components/bq-checkbox.js';
+import { defineCustomElement as defineBqDialog } from '@beeq/core/dist/components/bq-dialog.js';
+import { defineCustomElement as defineBqDivider } from '@beeq/core/dist/components/bq-divider.js';
+import { defineCustomElement as defineBqDrawer } from '@beeq/core/dist/components/bq-drawer.js';
+import { defineCustomElement as defineBqDropdown } from '@beeq/core/dist/components/bq-dropdown.js';
+import { defineCustomElement as defineBqEmptyState } from '@beeq/core/dist/components/bq-empty-state.js';
+import { defineCustomElement as defineBqIcon } from '@beeq/core/dist/components/bq-icon.js';
+import { defineCustomElement as defineBqInput } from '@beeq/core/dist/components/bq-input.js';
+import { defineCustomElement as defineBqNotification } from '@beeq/core/dist/components/bq-notification.js';
+import { defineCustomElement as defineBqOption } from '@beeq/core/dist/components/bq-option.js';
+import { defineCustomElement as defineBqOptionGroup } from '@beeq/core/dist/components/bq-option-group.js';
+import { defineCustomElement as defineBqOptionList } from '@beeq/core/dist/components/bq-option-list.js';
+import { defineCustomElement as defineBqPanel } from '@beeq/core/dist/components/bq-panel.js';
+import { defineCustomElement as defineBqProgress } from '@beeq/core/dist/components/bq-progress.js';
+import { defineCustomElement as defineBqRadio } from '@beeq/core/dist/components/bq-radio.js';
+import { defineCustomElement as defineBqRadioGroup } from '@beeq/core/dist/components/bq-radio-group.js';
+import { defineCustomElement as defineBqSelect } from '@beeq/core/dist/components/bq-select.js';
+import { defineCustomElement as defineBqSideMenu } from '@beeq/core/dist/components/bq-side-menu.js';
+import { defineCustomElement as defineBqSideMenuItem } from '@beeq/core/dist/components/bq-side-menu-item.js';
+import { defineCustomElement as defineBqSlider } from '@beeq/core/dist/components/bq-slider.js';
+import { defineCustomElement as defineBqSpinner } from '@beeq/core/dist/components/bq-spinner.js';
+import { defineCustomElement as defineBqStatus } from '@beeq/core/dist/components/bq-status.js';
+import { defineCustomElement as defineBqStepItem } from '@beeq/core/dist/components/bq-step-item.js';
+import { defineCustomElement as defineBqSteps } from '@beeq/core/dist/components/bq-steps.js';
+import { defineCustomElement as defineBqSwitch } from '@beeq/core/dist/components/bq-switch.js';
+import { defineCustomElement as defineBqTab } from '@beeq/core/dist/components/bq-tab.js';
+import { defineCustomElement as defineBqTabGroup } from '@beeq/core/dist/components/bq-tab-group.js';
+import { defineCustomElement as defineBqTag } from '@beeq/core/dist/components/bq-tag.js';
+import { defineCustomElement as defineBqTextarea } from '@beeq/core/dist/components/bq-textarea.js';
+import { defineCustomElement as defineBqToast } from '@beeq/core/dist/components/bq-toast.js';
+import { defineCustomElement as defineBqTooltip } from '@beeq/core/dist/components/bq-tooltip.js';
+import * as i0 from "@angular/core";
+let BqAccordion = class BqAccordion {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqOpen', 'bqAfterOpen', 'bqClose', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAccordion, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqAccordion, isStandalone: true, selector: "bq-accordion", inputs: { appearance: "appearance", disabled: "disabled", expanded: "expanded", rotate: "rotate", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqAccordion = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqAccordion,
+        inputs: ['appearance', 'disabled', 'expanded', 'rotate', 'size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAccordion);
+export { BqAccordion };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAccordion, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-accordion',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['appearance', 'disabled', 'expanded', 'rotate', 'size'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqAccordionGroup = class BqAccordionGroup {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAccordionGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqAccordionGroup, isStandalone: true, selector: "bq-accordion-group", inputs: { appearance: "appearance", expandAll: "expandAll", multiple: "multiple", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqAccordionGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqAccordionGroup,
+        inputs: ['appearance', 'expandAll', 'multiple', 'size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAccordionGroup);
+export { BqAccordionGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAccordionGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-accordion-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['appearance', 'expandAll', 'multiple', 'size'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqAlert = class BqAlert {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAlert, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqAlert, isStandalone: true, selector: "bq-alert", inputs: { autoDismiss: "autoDismiss", border: "border", disableClose: "disableClose", hideIcon: "hideIcon", open: "open", sticky: "sticky", time: "time", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqAlert = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqAlert,
+        inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'sticky', 'time', 'type'],
+        methods: ['hide', 'show']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAlert);
+export { BqAlert };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAlert, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-alert',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'sticky', 'time', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqAvatar = class BqAvatar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAvatar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqAvatar, isStandalone: true, selector: "bq-avatar", inputs: { altText: "altText", image: "image", initials: "initials", label: "label", shape: "shape", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqAvatar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqAvatar,
+        inputs: ['altText', 'image', 'initials', 'label', 'shape', 'size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAvatar);
+export { BqAvatar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqAvatar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-avatar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['altText', 'image', 'initials', 'label', 'shape', 'size'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqBadge = class BqBadge {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqBadge, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqBadge, isStandalone: true, selector: "bq-badge", inputs: { backgroundColor: "backgroundColor", size: "size", textColor: "textColor" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqBadge = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqBadge,
+        inputs: ['backgroundColor', 'size', 'textColor']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqBadge);
+export { BqBadge };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-badge',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['backgroundColor', 'size', 'textColor'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqBreadcrumb = class BqBreadcrumb {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBreadcrumbBlur', 'bqBreadcrumbFocus', 'bqBreadcrumbClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqBreadcrumb, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqBreadcrumb, isStandalone: true, selector: "bq-breadcrumb", inputs: { ariaLabel: "ariaLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqBreadcrumb = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqBreadcrumb,
+        inputs: ['ariaLabel']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqBreadcrumb);
+export { BqBreadcrumb };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqBreadcrumb, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-breadcrumb',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['ariaLabel'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqBreadcrumbItem = class BqBreadcrumbItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqBreadcrumbItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqBreadcrumbItem, isStandalone: true, selector: "bq-breadcrumb-item", inputs: { ariaLabel: "ariaLabel", href: "href", isLastItem: "isLastItem", rel: "rel", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqBreadcrumbItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqBreadcrumbItem,
+        inputs: ['ariaLabel', 'href', 'isLastItem', 'rel', 'target']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqBreadcrumbItem);
+export { BqBreadcrumbItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqBreadcrumbItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-breadcrumb-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['ariaLabel', 'href', 'isLastItem', 'rel', 'target'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqButton = class BqButton {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqButton, isStandalone: true, selector: "bq-button", inputs: { appearance: "appearance", block: "block", border: "border", disabled: "disabled", download: "download", href: "href", justifyContent: "justifyContent", loading: "loading", size: "size", target: "target", type: "type", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqButton = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqButton,
+        inputs: ['appearance', 'block', 'border', 'disabled', 'download', 'href', 'justifyContent', 'loading', 'size', 'target', 'type', 'variant']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqButton);
+export { BqButton };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['appearance', 'block', 'border', 'disabled', 'download', 'href', 'justifyContent', 'loading', 'size', 'target', 'type', 'variant'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqCard = class BqCard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqCard, isStandalone: true, selector: "bq-card", inputs: { border: "border", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqCard,
+        inputs: ['border', 'type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqCard);
+export { BqCard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['border', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqCheckbox = class BqCheckbox {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange', 'bqFocus', 'bqBlur']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqCheckbox, isStandalone: true, selector: "bq-checkbox", inputs: { backgroundOnHover: "backgroundOnHover", checked: "checked", disabled: "disabled", formId: "formId", indeterminate: "indeterminate", name: "name", required: "required", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqCheckbox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqCheckbox,
+        inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'indeterminate', 'name', 'required', 'value'],
+        methods: ['vClick', 'vFocus', 'vBlur']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqCheckbox);
+export { BqCheckbox };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqCheckbox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-checkbox',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'indeterminate', 'name', 'required', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDialog = class BqDialog {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqCancel', 'bqClose', 'bqOpen', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDialog, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqDialog, isStandalone: true, selector: "bq-dialog", inputs: { border: "border", disableBackdrop: "disableBackdrop", disableCloseClickOutside: "disableCloseClickOutside", disableCloseEscKeydown: "disableCloseEscKeydown", footerAppearance: "footerAppearance", hideCloseButton: "hideCloseButton", open: "open", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqDialog = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqDialog,
+        inputs: ['border', 'disableBackdrop', 'disableCloseClickOutside', 'disableCloseEscKeydown', 'footerAppearance', 'hideCloseButton', 'open', 'size'],
+        methods: ['show', 'hide', 'cancel']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqDialog);
+export { BqDialog };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDialog, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-dialog',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['border', 'disableBackdrop', 'disableCloseClickOutside', 'disableCloseEscKeydown', 'footerAppearance', 'hideCloseButton', 'open', 'size'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDivider = class BqDivider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqDivider, isStandalone: true, selector: "bq-divider", inputs: { dashed: "dashed", orientation: "orientation", strokeBasis: "strokeBasis", strokeColor: "strokeColor", strokeDashGap: "strokeDashGap", strokeDashWidth: "strokeDashWidth", strokeLinecap: "strokeLinecap", strokeThickness: "strokeThickness", titleAlignment: "titleAlignment" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqDivider = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqDivider,
+        inputs: ['dashed', 'orientation', 'strokeBasis', 'strokeColor', 'strokeDashGap', 'strokeDashWidth', 'strokeLinecap', 'strokeThickness', 'titleAlignment']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqDivider);
+export { BqDivider };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDivider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-divider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['dashed', 'orientation', 'strokeBasis', 'strokeColor', 'strokeDashGap', 'strokeDashWidth', 'strokeLinecap', 'strokeThickness', 'titleAlignment'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDrawer = class BqDrawer {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClose', 'bqOpen', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDrawer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqDrawer, isStandalone: true, selector: "bq-drawer", inputs: { closeOnClickOutside: "closeOnClickOutside", closeOnEsc: "closeOnEsc", enableBackdrop: "enableBackdrop", open: "open", placement: "placement" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqDrawer = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqDrawer,
+        inputs: ['closeOnClickOutside', 'closeOnEsc', 'enableBackdrop', 'open', 'placement'],
+        methods: ['hide', 'show']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqDrawer);
+export { BqDrawer };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDrawer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-drawer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['closeOnClickOutside', 'closeOnEsc', 'enableBackdrop', 'open', 'placement'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDropdown = class BqDropdown {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqOpen']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDropdown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqDropdown, isStandalone: true, selector: "bq-dropdown", inputs: { disabled: "disabled", distance: "distance", keepOpenOnSelect: "keepOpenOnSelect", open: "open", panelHeight: "panelHeight", placement: "placement", sameWidth: "sameWidth", skidding: "skidding", strategy: "strategy" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqDropdown = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqDropdown,
+        inputs: ['disabled', 'distance', 'keepOpenOnSelect', 'open', 'panelHeight', 'placement', 'sameWidth', 'skidding', 'strategy']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqDropdown);
+export { BqDropdown };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqDropdown, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-dropdown',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'distance', 'keepOpenOnSelect', 'open', 'panelHeight', 'placement', 'sameWidth', 'skidding', 'strategy'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqEmptyState = class BqEmptyState {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqEmptyState, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqEmptyState, isStandalone: true, selector: "bq-empty-state", inputs: { size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqEmptyState = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqEmptyState,
+        inputs: ['size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqEmptyState);
+export { BqEmptyState };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqEmptyState, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-empty-state',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['size'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqIcon = class BqIcon {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['svgLoaded']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqIcon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqIcon, isStandalone: true, selector: "bq-icon", inputs: { color: "color", label: "label", name: "name", size: "size", src: "src", weight: "weight" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqIcon = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqIcon,
+        inputs: ['color', 'label', 'name', 'size', 'src', 'weight']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqIcon);
+export { BqIcon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqIcon, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-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', 'weight'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqInput = class BqInput {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus', 'bqInput']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqInput, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqInput, isStandalone: true, selector: "bq-input", inputs: { autocapitalize: "autocapitalize", autocomplete: "autocomplete", autocorrect: "autocorrect", autofocus: "autofocus", clearButtonLabel: "clearButtonLabel", debounceTime: "debounceTime", disableClear: "disableClear", disabled: "disabled", form: "form", inputmode: "inputmode", max: "max", maxlength: "maxlength", min: "min", minlength: "minlength", name: "name", pattern: "pattern", placeholder: "placeholder", readonly: "readonly", required: "required", step: "step", type: "type", validationStatus: "validationStatus", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqInput = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqInput,
+        inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'form', 'inputmode', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'step', 'type', 'validationStatus', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqInput);
+export { BqInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-input',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'form', 'inputmode', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'step', 'type', 'validationStatus', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqNotification = class BqNotification {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqNotification, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqNotification, isStandalone: true, selector: "bq-notification", inputs: { autoDismiss: "autoDismiss", border: "border", disableClose: "disableClose", hideIcon: "hideIcon", open: "open", time: "time", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqNotification = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqNotification,
+        inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'time', 'type'],
+        methods: ['hide', 'show', 'toast']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqNotification);
+export { BqNotification };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqNotification, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-notification',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'time', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqOption = class BqOption {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick', 'bqEnter']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqOption, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqOption, isStandalone: true, selector: "bq-option", inputs: { disabled: "disabled", selected: "selected", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqOption = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqOption,
+        inputs: ['disabled', 'selected', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqOption);
+export { BqOption };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqOption, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-option',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['disabled', 'selected', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqOptionGroup = class BqOptionGroup {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqOptionGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqOptionGroup, isStandalone: true, selector: "bq-option-group", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqOptionGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqOptionGroup
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqOptionGroup);
+export { BqOptionGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqOptionGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-option-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqOptionList = class BqOptionList {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqSelect']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqOptionList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqOptionList, isStandalone: true, selector: "bq-option-list", inputs: { ariaLabel: "ariaLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqOptionList = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqOptionList,
+        inputs: ['ariaLabel']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqOptionList);
+export { BqOptionList };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqOptionList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-option-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['ariaLabel'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqPanel = class BqPanel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqPanel, isStandalone: true, selector: "bq-panel", inputs: { distance: "distance", open: "open", placement: "placement", sameWidth: "sameWidth", skidding: "skidding", strategy: "strategy" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqPanel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqPanel,
+        inputs: ['distance', 'open', 'placement', 'sameWidth', 'skidding', 'strategy']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqPanel);
+export { BqPanel };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['distance', 'open', 'placement', 'sameWidth', 'skidding', 'strategy'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqProgress = class BqProgress {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqProgress, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqProgress, isStandalone: true, selector: "bq-progress", inputs: { borderShape: "borderShape", enableTooltip: "enableTooltip", indeterminate: "indeterminate", label: "label", thickness: "thickness", type: "type", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqProgress = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqProgress,
+        inputs: ['borderShape', 'enableTooltip', 'indeterminate', 'label', 'thickness', 'type', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqProgress);
+export { BqProgress };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqProgress, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-progress',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['borderShape', 'enableTooltip', 'indeterminate', 'label', 'thickness', 'type', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqRadio = class BqRadio {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClick', 'bqFocus', 'bqBlur', 'bqKeyDown']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqRadio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqRadio, isStandalone: true, selector: "bq-radio", inputs: { backgroundOnHover: "backgroundOnHover", checked: "checked", disabled: "disabled", formId: "formId", name: "name", required: "required", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqRadio = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqRadio,
+        inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'name', 'required', 'value'],
+        methods: ['vClick', 'vFocus', 'vBlur']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqRadio);
+export { BqRadio };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqRadio, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-radio',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'name', 'required', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqRadioGroup = class BqRadioGroup {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqRadioGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqRadioGroup, isStandalone: true, selector: "bq-radio-group", inputs: { backgroundOnHover: "backgroundOnHover", debounceTime: "debounceTime", disabled: "disabled", fieldset: "fieldset", name: "name", orientation: "orientation", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqRadioGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqRadioGroup,
+        inputs: ['backgroundOnHover', 'debounceTime', 'disabled', 'fieldset', 'name', 'orientation', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqRadioGroup);
+export { BqRadioGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqRadioGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-radio-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['backgroundOnHover', 'debounceTime', 'disabled', 'fieldset', 'name', 'orientation', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSelect = class BqSelect {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqClear', 'bqFocus', 'bqSelect']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSelect, isStandalone: true, selector: "bq-select", inputs: { autofocus: "autofocus", clearButtonLabel: "clearButtonLabel", disableClear: "disableClear", disabled: "disabled", distance: "distance", form: "form", keepOpenOnSelect: "keepOpenOnSelect", name: "name", open: "open", panelHeight: "panelHeight", placeholder: "placeholder", placement: "placement", readonly: "readonly", required: "required", sameWidth: "sameWidth", skidding: "skidding", strategy: "strategy", validationStatus: "validationStatus", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSelect = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSelect,
+        inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'readonly', 'required', 'sameWidth', 'skidding', 'strategy', 'validationStatus', 'value'],
+        methods: ['clear']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSelect);
+export { BqSelect };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-select',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'readonly', 'required', 'sameWidth', 'skidding', 'strategy', 'validationStatus', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSideMenu = class BqSideMenu {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqCollapse', 'bqSelect']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSideMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSideMenu, isStandalone: true, selector: "bq-side-menu", inputs: { appearance: "appearance", collapse: "collapse", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSideMenu = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSideMenu,
+        inputs: ['appearance', 'collapse', 'size'],
+        methods: ['toggleCollapse']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSideMenu);
+export { BqSideMenu };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSideMenu, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-side-menu',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['appearance', 'collapse', 'size'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSideMenuItem = class BqSideMenuItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSideMenuItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSideMenuItem, isStandalone: true, selector: "bq-side-menu-item", inputs: { active: "active", collapse: "collapse", disabled: "disabled" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSideMenuItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSideMenuItem,
+        inputs: ['active', 'collapse', 'disabled']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSideMenuItem);
+export { BqSideMenuItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSideMenuItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-side-menu-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'collapse', 'disabled'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSlider = class BqSlider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange', 'bqBlur', 'bqFocus']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSlider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSlider, isStandalone: true, selector: "bq-slider", inputs: { debounceTime: "debounceTime", disabled: "disabled", gap: "gap", max: "max", min: "min", step: "step", type: "type", value: "value", valueIndicator: "valueIndicator" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSlider = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSlider,
+        inputs: ['debounceTime', 'disabled', 'gap', 'max', 'min', 'step', 'type', 'value', 'valueIndicator']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSlider);
+export { BqSlider };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSlider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-slider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['debounceTime', 'disabled', 'gap', 'max', 'min', 'step', 'type', 'value', 'valueIndicator'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSpinner = class BqSpinner {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSpinner, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSpinner, isStandalone: true, selector: "bq-spinner", inputs: { animation: "animation", size: "size", textPosition: "textPosition" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSpinner = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSpinner,
+        inputs: ['animation', 'size', 'textPosition']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSpinner);
+export { BqSpinner };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSpinner, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-spinner',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animation', 'size', 'textPosition'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqStatus = class BqStatus {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqStatus, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqStatus, isStandalone: true, selector: "bq-status", inputs: { type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqStatus = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqStatus,
+        inputs: ['type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqStatus);
+export { BqStatus };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqStatus, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-status',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqStepItem = class BqStepItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqStepItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqStepItem, isStandalone: true, selector: "bq-step-item", inputs: { size: "size", status: "status", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqStepItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqStepItem,
+        inputs: ['size', 'status', 'type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqStepItem);
+export { BqStepItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqStepItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-step-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['size', 'status', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSteps = class BqSteps {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSteps, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSteps, isStandalone: true, selector: "bq-steps", inputs: { dividerColor: "dividerColor", size: "size", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSteps = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSteps,
+        inputs: ['dividerColor', 'size', 'type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSteps);
+export { BqSteps };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSteps, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-steps',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['dividerColor', 'size', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSwitch = class BqSwitch {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange', 'bqFocus', 'bqBlur']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSwitch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqSwitch, isStandalone: true, selector: "bq-switch", inputs: { backgroundOnHover: "backgroundOnHover", checked: "checked", disabled: "disabled", fullWidth: "fullWidth", innerLabel: "innerLabel", justifyContent: "justifyContent", name: "name", required: "required", reverseOrder: "reverseOrder", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqSwitch = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqSwitch,
+        inputs: ['backgroundOnHover', 'checked', 'disabled', 'fullWidth', 'innerLabel', 'justifyContent', 'name', 'required', 'reverseOrder', 'value'],
+        methods: ['vClick', 'vFocus', 'vBlur']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSwitch);
+export { BqSwitch };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqSwitch, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-switch',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['backgroundOnHover', 'checked', 'disabled', 'fullWidth', 'innerLabel', 'justifyContent', 'name', 'required', 'reverseOrder', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTab = class BqTab {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClick', 'bqFocus', 'bqBlur', 'bqKeyDown']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqTab, isStandalone: true, selector: "bq-tab", inputs: { active: "active", controls: "controls", disabled: "disabled", size: "size", tabId: "tabId" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqTab = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqTab,
+        inputs: ['active', 'controls', 'disabled', 'size', 'tabId'],
+        methods: ['vClick', 'vFocus', 'vBlur', 'enableFocus']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTab);
+export { BqTab };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-tab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'controls', 'disabled', 'size', 'tabId'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTabGroup = class BqTabGroup {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTabGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqTabGroup, isStandalone: true, selector: "bq-tab-group", inputs: { debounceTime: "debounceTime", disableDivider: "disableDivider", size: "size", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqTabGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqTabGroup,
+        inputs: ['debounceTime', 'disableDivider', 'size', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTabGroup);
+export { BqTabGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTabGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-tab-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['debounceTime', 'disableDivider', 'size', 'value'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTag = class BqTag {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClose', 'bqOpen', 'bqBlur', 'bqClick', 'bqFocus']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTag, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqTag, isStandalone: true, selector: "bq-tag", inputs: { border: "border", clickable: "clickable", color: "color", disabled: "disabled", hidden: "hidden", removable: "removable", selected: "selected", size: "size", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqTag = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqTag,
+        inputs: ['border', 'clickable', 'color', 'disabled', 'hidden', 'removable', 'selected', 'size', 'variant'],
+        methods: ['hide', 'show']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTag);
+export { BqTag };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTag, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-tag',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['border', 'clickable', 'color', 'disabled', 'hidden', 'removable', 'selected', 'size', 'variant'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTextarea = class BqTextarea {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus', 'bqInput']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTextarea, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqTextarea, isStandalone: true, selector: "bq-textarea", inputs: { autoGrow: "autoGrow", autocapitalize: "autocapitalize", autocomplete: "autocomplete", autocorrect: "autocorrect", autofocus: "autofocus", debounceTime: "debounceTime", disableResize: "disableResize", disabled: "disabled", form: "form", maxlength: "maxlength", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", rows: "rows", spellcheck: "spellcheck", validationStatus: "validationStatus", value: "value", wrap: "wrap" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqTextarea = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqTextarea,
+        inputs: ['autoGrow', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'debounceTime', 'disableResize', 'disabled', 'form', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'rows', 'spellcheck', 'validationStatus', 'value', 'wrap']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTextarea);
+export { BqTextarea };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTextarea, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-textarea',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoGrow', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'debounceTime', 'disableResize', 'disabled', 'form', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'rows', 'spellcheck', 'validationStatus', 'value', 'wrap'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqToast = class BqToast {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqHide', 'bqShow']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqToast, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqToast, isStandalone: true, selector: "bq-toast", inputs: { border: "border", hideIcon: "hideIcon", open: "open", placement: "placement", time: "time", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqToast = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqToast,
+        inputs: ['border', 'hideIcon', 'open', 'placement', 'time', 'type'],
+        methods: ['show', 'hide', 'toast']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqToast);
+export { BqToast };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqToast, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-toast',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['border', 'hideIcon', 'open', 'placement', 'time', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTooltip = class BqTooltip {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTooltip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: BqTooltip, isStandalone: true, selector: "bq-tooltip", inputs: { alwaysVisible: "alwaysVisible", displayOn: "displayOn", distance: "distance", hideArrow: "hideArrow", placement: "placement", sameWidth: "sameWidth", visible: "visible" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+BqTooltip = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineBqTooltip,
+        inputs: ['alwaysVisible', 'displayOn', 'distance', 'hideArrow', 'placement', 'sameWidth', 'visible'],
+        methods: ['show', 'hide']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTooltip);
+export { BqTooltip };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: BqTooltip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-tooltip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['alwaysVisible', 'displayOn', 'distance', 'hideArrow', 'placement', 'sameWidth', 'visible'],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../../../packages/beeq-angular/standalone/src/directives/components.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* auto-generated angular directive proxies */\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, NgZone } from '@angular/core';\n\nimport { ProxyCmp, proxyOutputs } from './angular-component-lib/utils';\n\nimport type { Components } from '@beeq/core/dist/components';\n\nimport { defineCustomElement as defineBqAccordion } from '@beeq/core/dist/components/bq-accordion.js';\nimport { defineCustomElement as defineBqAccordionGroup } from '@beeq/core/dist/components/bq-accordion-group.js';\nimport { defineCustomElement as defineBqAlert } from '@beeq/core/dist/components/bq-alert.js';\nimport { defineCustomElement as defineBqAvatar } from '@beeq/core/dist/components/bq-avatar.js';\nimport { defineCustomElement as defineBqBadge } from '@beeq/core/dist/components/bq-badge.js';\nimport { defineCustomElement as defineBqBreadcrumb } from '@beeq/core/dist/components/bq-breadcrumb.js';\nimport { defineCustomElement as defineBqBreadcrumbItem } from '@beeq/core/dist/components/bq-breadcrumb-item.js';\nimport { defineCustomElement as defineBqButton } from '@beeq/core/dist/components/bq-button.js';\nimport { defineCustomElement as defineBqCard } from '@beeq/core/dist/components/bq-card.js';\nimport { defineCustomElement as defineBqCheckbox } from '@beeq/core/dist/components/bq-checkbox.js';\nimport { defineCustomElement as defineBqDialog } from '@beeq/core/dist/components/bq-dialog.js';\nimport { defineCustomElement as defineBqDivider } from '@beeq/core/dist/components/bq-divider.js';\nimport { defineCustomElement as defineBqDrawer } from '@beeq/core/dist/components/bq-drawer.js';\nimport { defineCustomElement as defineBqDropdown } from '@beeq/core/dist/components/bq-dropdown.js';\nimport { defineCustomElement as defineBqEmptyState } from '@beeq/core/dist/components/bq-empty-state.js';\nimport { defineCustomElement as defineBqIcon } from '@beeq/core/dist/components/bq-icon.js';\nimport { defineCustomElement as defineBqInput } from '@beeq/core/dist/components/bq-input.js';\nimport { defineCustomElement as defineBqNotification } from '@beeq/core/dist/components/bq-notification.js';\nimport { defineCustomElement as defineBqOption } from '@beeq/core/dist/components/bq-option.js';\nimport { defineCustomElement as defineBqOptionGroup } from '@beeq/core/dist/components/bq-option-group.js';\nimport { defineCustomElement as defineBqOptionList } from '@beeq/core/dist/components/bq-option-list.js';\nimport { defineCustomElement as defineBqPanel } from '@beeq/core/dist/components/bq-panel.js';\nimport { defineCustomElement as defineBqProgress } from '@beeq/core/dist/components/bq-progress.js';\nimport { defineCustomElement as defineBqRadio } from '@beeq/core/dist/components/bq-radio.js';\nimport { defineCustomElement as defineBqRadioGroup } from '@beeq/core/dist/components/bq-radio-group.js';\nimport { defineCustomElement as defineBqSelect } from '@beeq/core/dist/components/bq-select.js';\nimport { defineCustomElement as defineBqSideMenu } from '@beeq/core/dist/components/bq-side-menu.js';\nimport { defineCustomElement as defineBqSideMenuItem } from '@beeq/core/dist/components/bq-side-menu-item.js';\nimport { defineCustomElement as defineBqSlider } from '@beeq/core/dist/components/bq-slider.js';\nimport { defineCustomElement as defineBqSpinner } from '@beeq/core/dist/components/bq-spinner.js';\nimport { defineCustomElement as defineBqStatus } from '@beeq/core/dist/components/bq-status.js';\nimport { defineCustomElement as defineBqStepItem } from '@beeq/core/dist/components/bq-step-item.js';\nimport { defineCustomElement as defineBqSteps } from '@beeq/core/dist/components/bq-steps.js';\nimport { defineCustomElement as defineBqSwitch } from '@beeq/core/dist/components/bq-switch.js';\nimport { defineCustomElement as defineBqTab } from '@beeq/core/dist/components/bq-tab.js';\nimport { defineCustomElement as defineBqTabGroup } from '@beeq/core/dist/components/bq-tab-group.js';\nimport { defineCustomElement as defineBqTag } from '@beeq/core/dist/components/bq-tag.js';\nimport { defineCustomElement as defineBqTextarea } from '@beeq/core/dist/components/bq-textarea.js';\nimport { defineCustomElement as defineBqToast } from '@beeq/core/dist/components/bq-toast.js';\nimport { defineCustomElement as defineBqTooltip } from '@beeq/core/dist/components/bq-tooltip.js';\n@ProxyCmp({\n  defineCustomElementFn: defineBqAccordion,\n  inputs: ['appearance', 'disabled', 'expanded', 'rotate', 'size']\n})\n@Component({\n  selector: 'bq-accordion',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['appearance', 'disabled', 'expanded', 'rotate', 'size'],\n  standalone: true\n})\nexport class BqAccordion {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqOpen', 'bqAfterOpen', 'bqClose', 'bqAfterClose']);\n  }\n}\n\n\nexport declare interface BqAccordion extends Components.BqAccordion {\n  /**\n   * Handler to be called when the accordion loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n  /**\n   * Handler to be called when the accordion gets focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n  /**\n   * Handler to be called when the accordion is opened\n   */\n  bqOpen: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n  /**\n   * Handler to be called after the accordion is opened\n   */\n  bqAfterOpen: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n  /**\n   * Handler to be called when the accordion is closed\n   */\n  bqClose: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n  /**\n   * Handler to be called after the accordion is closed\n   */\n  bqAfterClose: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqAccordionGroup,\n  inputs: ['appearance', 'expandAll', 'multiple', 'size']\n})\n@Component({\n  selector: 'bq-accordion-group',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['appearance', 'expandAll', 'multiple', 'size'],\n  standalone: true\n})\nexport class BqAccordionGroup {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqAccordionGroup extends Components.BqAccordionGroup {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqAlert,\n  inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'sticky', 'time', 'type'],\n  methods: ['hide', 'show']\n})\n@Component({\n  selector: 'bq-alert',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'sticky', 'time', 'type'],\n  standalone: true\n})\nexport class BqAlert {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterOpen', 'bqAfterClose']);\n  }\n}\n\n\nexport declare interface BqAlert extends Components.BqAlert {\n  /**\n   * Callback handler to be called when the alert is hidden\n   */\n  bqHide: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called when the alert is shown\n   */\n  bqShow: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the alert has been opened\n   */\n  bqAfterOpen: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the alert has been closed\n   */\n  bqAfterClose: EventEmitter<CustomEvent<any>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqAvatar,\n  inputs: ['altText', 'image', 'initials', 'label', 'shape', 'size']\n})\n@Component({\n  selector: 'bq-avatar',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['altText', 'image', 'initials', 'label', 'shape', 'size'],\n  standalone: true\n})\nexport class BqAvatar {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqAvatar extends Components.BqAvatar {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqBadge,\n  inputs: ['backgroundColor', 'size', 'textColor']\n})\n@Component({\n  selector: 'bq-badge',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['backgroundColor', 'size', 'textColor'],\n  standalone: true\n})\nexport class BqBadge {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqBadge extends Components.BqBadge {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqBreadcrumb,\n  inputs: ['ariaLabel']\n})\n@Component({\n  selector: 'bq-breadcrumb',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['ariaLabel'],\n  standalone: true\n})\nexport class BqBreadcrumb {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBreadcrumbBlur', 'bqBreadcrumbFocus', 'bqBreadcrumbClick']);\n  }\n}\n\n\nexport declare interface BqBreadcrumb extends Components.BqBreadcrumb {\n  /**\n   * Handler to be called when `bq-breadcrumb-item` item loses focus.\n   */\n  bqBreadcrumbBlur: EventEmitter<CustomEvent<HTMLBqBreadcrumbItemElement>>;\n  /**\n   * Handler to be called when `bq-breadcrumb-item` item gets focus.\n   */\n  bqBreadcrumbFocus: EventEmitter<CustomEvent<HTMLBqBreadcrumbItemElement>>;\n  /**\n   * Handler to be called when `bq-breadcrumb-item` is selected (on click/enter press).\n   */\n  bqBreadcrumbClick: EventEmitter<CustomEvent<HTMLBqBreadcrumbItemElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqBreadcrumbItem,\n  inputs: ['ariaLabel', 'href', 'isLastItem', 'rel', 'target']\n})\n@Component({\n  selector: 'bq-breadcrumb-item',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['ariaLabel', 'href', 'isLastItem', 'rel', 'target'],\n  standalone: true\n})\nexport class BqBreadcrumbItem {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);\n  }\n}\n\n\nexport declare interface BqBreadcrumbItem extends Components.BqBreadcrumbItem {\n  /**\n   * Handler to be called when item loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqBreadcrumbItemElement>>;\n  /**\n   * Handler to be called when item is focused\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqBreadcrumbItemElement>>;\n  /**\n   * Handler to be called when item is clicked\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqBreadcrumbItemElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqButton,\n  inputs: ['appearance', 'block', 'border', 'disabled', 'download', 'href', 'justifyContent', 'loading', 'size', 'target', 'type', 'variant']\n})\n@Component({\n  selector: 'bq-button',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['appearance', 'block', 'border', 'disabled', 'download', 'href', 'justifyContent', 'loading', 'size', 'target', 'type', 'variant'],\n  standalone: true\n})\nexport class BqButton {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);\n  }\n}\n\n\nexport declare interface BqButton extends Components.BqButton {\n  /**\n   * Handler to be called when the button loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqButtonElement>>;\n  /**\n   * Handler to be called when the button is clicked\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqButtonElement>>;\n  /**\n   * Handler to be called when button gets focus\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqButtonElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqCard,\n  inputs: ['border', 'type']\n})\n@Component({\n  selector: 'bq-card',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['border', 'type'],\n  standalone: true\n})\nexport class BqCard {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqCard extends Components.BqCard {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqCheckbox,\n  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'indeterminate', 'name', 'required', 'value'],\n  methods: ['vClick', 'vFocus', 'vBlur']\n})\n@Component({\n  selector: 'bq-checkbox',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'indeterminate', 'name', 'required', 'value'],\n  standalone: true\n})\nexport class BqCheckbox {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqChange', 'bqFocus', 'bqBlur']);\n  }\n}\n\n\nexport declare interface BqCheckbox extends Components.BqCheckbox {\n  /**\n   * Handler to be called when the chebkbox state changes\n   */\n  bqChange: EventEmitter<CustomEvent<{ checked: boolean }>>;\n  /**\n   * Handler to be called when the checkbox gets focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqCheckboxElement>>;\n  /**\n   * Handler to be called when the checkbox loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqCheckboxElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqDialog,\n  inputs: ['border', 'disableBackdrop', 'disableCloseClickOutside', 'disableCloseEscKeydown', 'footerAppearance', 'hideCloseButton', 'open', 'size'],\n  methods: ['show', 'hide', 'cancel']\n})\n@Component({\n  selector: 'bq-dialog',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['border', 'disableBackdrop', 'disableCloseClickOutside', 'disableCloseEscKeydown', 'footerAppearance', 'hideCloseButton', 'open', 'size'],\n  standalone: true\n})\nexport class BqDialog {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqCancel', 'bqClose', 'bqOpen', 'bqAfterOpen', 'bqAfterClose']);\n  }\n}\n\n\nexport declare interface BqDialog extends Components.BqDialog {\n  /**\n   * Callback handler emitted when the dialog has been canceled or dismissed\n   */\n  bqCancel: EventEmitter<CustomEvent<void>>;\n  /**\n   * Callback handler emitted when the dialog will close\n   */\n  bqClose: EventEmitter<CustomEvent<void>>;\n  /**\n   * Callback handler emitted when the dialog will open\n   */\n  bqOpen: EventEmitter<CustomEvent<void>>;\n  /**\n   * Callback handler emitted when the dialog finish opening\n   */\n  bqAfterOpen: EventEmitter<CustomEvent<void>>;\n  /**\n   * Callback handler emitted when the dialog finish closing\n   */\n  bqAfterClose: EventEmitter<CustomEvent<void>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqDivider,\n  inputs: ['dashed', 'orientation', 'strokeBasis', 'strokeColor', 'strokeDashGap', 'strokeDashWidth', 'strokeLinecap', 'strokeThickness', 'titleAlignment']\n})\n@Component({\n  selector: 'bq-divider',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['dashed', 'orientation', 'strokeBasis', 'strokeColor', 'strokeDashGap', 'strokeDashWidth', 'strokeLinecap', 'strokeThickness', 'titleAlignment'],\n  standalone: true\n})\nexport class BqDivider {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqDivider extends Components.BqDivider {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqDrawer,\n  inputs: ['closeOnClickOutside', 'closeOnEsc', 'enableBackdrop', 'open', 'placement'],\n  methods: ['hide', 'show']\n})\n@Component({\n  selector: 'bq-drawer',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['closeOnClickOutside', 'closeOnEsc', 'enableBackdrop', 'open', 'placement'],\n  standalone: true\n})\nexport class BqDrawer {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqClose', 'bqOpen', 'bqAfterOpen', 'bqAfterClose']);\n  }\n}\n\n\nexport declare interface BqDrawer extends Components.BqDrawer {\n  /**\n   * Callback handler to be called when the drawer is closed\n   */\n  bqClose: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called when the drawer is opened\n   */\n  bqOpen: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the drawer has been opened\n   */\n  bqAfterOpen: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the drawer has been closed\n   */\n  bqAfterClose: EventEmitter<CustomEvent<any>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqDropdown,\n  inputs: ['disabled', 'distance', 'keepOpenOnSelect', 'open', 'panelHeight', 'placement', 'sameWidth', 'skidding', 'strategy']\n})\n@Component({\n  selector: 'bq-dropdown',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['disabled', 'distance', 'keepOpenOnSelect', 'open', 'panelHeight', 'placement', 'sameWidth', 'skidding', 'strategy'],\n  standalone: true\n})\nexport class BqDropdown {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqOpen']);\n  }\n}\n\n\nexport declare interface BqDropdown extends Components.BqDropdown {\n  /**\n   * Callback handler to be called when the dropdown panel is opened or closed.\n   */\n  bqOpen: EventEmitter<CustomEvent<{ open: boolean }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqEmptyState,\n  inputs: ['size']\n})\n@Component({\n  selector: 'bq-empty-state',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['size'],\n  standalone: true\n})\nexport class BqEmptyState {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqEmptyState extends Components.BqEmptyState {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqIcon,\n  inputs: ['color', 'label', 'name', 'size', 'src', 'weight']\n})\n@Component({\n  selector: 'bq-icon',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['color', 'label', 'name', 'size', 'src', 'weight'],\n  standalone: true\n})\nexport class BqIcon {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['svgLoaded']);\n  }\n}\n\n\nexport declare interface BqIcon extends Components.BqIcon {\n  /**\n   * Callback handler to be called when the SVG has loaded\n   */\n  svgLoaded: EventEmitter<CustomEvent<any>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqInput,\n  inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'form', 'inputmode', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'step', 'type', 'validationStatus', 'value']\n})\n@Component({\n  selector: 'bq-input',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'form', 'inputmode', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'step', 'type', 'validationStatus', 'value'],\n  standalone: true\n})\nexport class BqInput {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus', 'bqInput']);\n  }\n}\n\n\nexport declare interface BqInput extends Components.BqInput {\n  /**\n   * Callback handler emitted when the input loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqInputElement>>;\n  /**\n   * Callback handler emitted when the input value has changed and the input loses focus.\nThis handler is called whenever the user finishes typing or pasting text into the input field and then clicks outside of the input field.\n   */\n  bqChange: EventEmitter<CustomEvent<{ value: string | number | string[]; el: HTMLBqInputElement }>>;\n  /**\n   * Callback handler emitted when the input value has been cleared\n   */\n  bqClear: EventEmitter<CustomEvent<HTMLBqInputElement>>;\n  /**\n   * Callback handler emitted when the input has received focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqInputElement>>;\n  /**\n   * Callback handler emitted when the input value changes.\nThis handler is called whenever the user types or pastes text into the input field.\n   */\n  bqInput: EventEmitter<CustomEvent<{ value: string | number | string[]; el: HTMLBqInputElement }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqNotification,\n  inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'time', 'type'],\n  methods: ['hide', 'show', 'toast']\n})\n@Component({\n  selector: 'bq-notification',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['autoDismiss', 'border', 'disableClose', 'hideIcon', 'open', 'time', 'type'],\n  standalone: true\n})\nexport class BqNotification {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterOpen', 'bqAfterClose']);\n  }\n}\n\n\nexport declare interface BqNotification extends Components.BqNotification {\n  /**\n   * Callback handler to be called when the notification is hidden\n   */\n  bqHide: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called when the notification is shown\n   */\n  bqShow: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the notification has been opened\n   */\n  bqAfterOpen: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the notification has been closed\n   */\n  bqAfterClose: EventEmitter<CustomEvent<any>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqOption,\n  inputs: ['disabled', 'selected', 'value']\n})\n@Component({\n  selector: 'bq-option',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['disabled', 'selected', 'value'],\n  standalone: true\n})\nexport class BqOption {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick', 'bqEnter']);\n  }\n}\n\n\nexport declare interface BqOption extends Components.BqOption {\n  /**\n   * Handler to be called when item loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqOptionElement>>;\n  /**\n   * Handler to be called when item is focused\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqOptionElement>>;\n  /**\n   * Handler to be called when item is clicked\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqOptionElement>>;\n  /**\n   * Handler to be called on enter key press\n   */\n  bqEnter: EventEmitter<CustomEvent<HTMLBqOptionElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqOptionGroup\n})\n@Component({\n  selector: 'bq-option-group',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: [],\n  standalone: true\n})\nexport class BqOptionGroup {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqOptionGroup extends Components.BqOptionGroup {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqOptionList,\n  inputs: ['ariaLabel']\n})\n@Component({\n  selector: 'bq-option-list',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['ariaLabel'],\n  standalone: true\n})\nexport class BqOptionList {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqSelect']);\n  }\n}\n\n\nexport declare interface BqOptionList extends Components.BqOptionList {\n  /**\n   * Handler to be called when `bq-option` is selected (on click/enter press).\n   */\n  bqSelect: EventEmitter<CustomEvent<{ value: string; item: HTMLBqOptionElement }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqPanel,\n  inputs: ['distance', 'open', 'placement', 'sameWidth', 'skidding', 'strategy']\n})\n@Component({\n  selector: 'bq-panel',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['distance', 'open', 'placement', 'sameWidth', 'skidding', 'strategy'],\n  standalone: true\n})\nexport class BqPanel {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqPanel extends Components.BqPanel {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqProgress,\n  inputs: ['borderShape', 'enableTooltip', 'indeterminate', 'label', 'thickness', 'type', 'value']\n})\n@Component({\n  selector: 'bq-progress',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['borderShape', 'enableTooltip', 'indeterminate', 'label', 'thickness', 'type', 'value'],\n  standalone: true\n})\nexport class BqProgress {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqProgress extends Components.BqProgress {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqRadio,\n  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'name', 'required', 'value'],\n  methods: ['vClick', 'vFocus', 'vBlur']\n})\n@Component({\n  selector: 'bq-radio',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'name', 'required', 'value'],\n  standalone: true\n})\nexport class BqRadio {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqClick', 'bqFocus', 'bqBlur', 'bqKeyDown']);\n  }\n}\n\n\nexport declare interface BqRadio extends Components.BqRadio {\n  /**\n   * Handler to be called when the radio state changes\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqRadioElement>>;\n  /**\n   * Handler to be called when the radio gets focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqRadioElement>>;\n  /**\n   * Handler to be called when the radio loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqRadioElement>>;\n  /**\n   * Handler to be called when the radio key is pressed\n   */\n  bqKeyDown: EventEmitter<CustomEvent<KeyboardEvent>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqRadioGroup,\n  inputs: ['backgroundOnHover', 'debounceTime', 'disabled', 'fieldset', 'name', 'orientation', 'value']\n})\n@Component({\n  selector: 'bq-radio-group',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['backgroundOnHover', 'debounceTime', 'disabled', 'fieldset', 'name', 'orientation', 'value'],\n  standalone: true\n})\nexport class BqRadioGroup {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqChange']);\n  }\n}\n\n\nexport declare interface BqRadioGroup extends Components.BqRadioGroup {\n  /**\n   * Handler to be called when the radio state changes\n   */\n  bqChange: EventEmitter<CustomEvent<{ value: string; target: HTMLBqRadioElement }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSelect,\n  inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'readonly', 'required', 'sameWidth', 'skidding', 'strategy', 'validationStatus', 'value'],\n  methods: ['clear']\n})\n@Component({\n  selector: 'bq-select',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'readonly', 'required', 'sameWidth', 'skidding', 'strategy', 'validationStatus', 'value'],\n  standalone: true\n})\nexport class BqSelect {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqClear', 'bqFocus', 'bqSelect']);\n  }\n}\n\n\nexport declare interface BqSelect extends Components.BqSelect {\n  /**\n   * Callback handler emitted when the Select input loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqSelectElement>>;\n  /**\n   * Callback handler emitted when the selected value has been cleared\n   */\n  bqClear: EventEmitter<CustomEvent<HTMLBqSelectElement>>;\n  /**\n   * Callback handler emitted when the Select input has received focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqSelectElement>>;\n  /**\n   * Callback handler emitted when the selected value has changed\n   */\n  bqSelect: EventEmitter<CustomEvent<{ value: string | number | string[]; item: HTMLBqOptionElement }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSideMenu,\n  inputs: ['appearance', 'collapse', 'size'],\n  methods: ['toggleCollapse']\n})\n@Component({\n  selector: 'bq-side-menu',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['appearance', 'collapse', 'size'],\n  standalone: true\n})\nexport class BqSideMenu {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqCollapse', 'bqSelect']);\n  }\n}\n\n\nexport declare interface BqSideMenu extends Components.BqSideMenu {\n  /**\n   * Callback handler to be called when the Side menu changes its width from expanded to collapse and vice versa\n   */\n  bqCollapse: EventEmitter<CustomEvent<{ collapse: boolean }>>;\n  /**\n   * Callback handler to be called when the active/selected menu item changes\n   */\n  bqSelect: EventEmitter<CustomEvent<HTMLBqSideMenuItemElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSideMenuItem,\n  inputs: ['active', 'collapse', 'disabled']\n})\n@Component({\n  selector: 'bq-side-menu-item',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['active', 'collapse', 'disabled'],\n  standalone: true\n})\nexport class BqSideMenuItem {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);\n  }\n}\n\n\nexport declare interface BqSideMenuItem extends Components.BqSideMenuItem {\n  /**\n   * Handler to be called when the button loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqSideMenuItemElement>>;\n  /**\n   * Handler to be called when the button is clicked\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqSideMenuItemElement>>;\n  /**\n   * Handler to be called when button gets focus\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqSideMenuItemElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSlider,\n  inputs: ['debounceTime', 'disabled', 'gap', 'max', 'min', 'step', 'type', 'value', 'valueIndicator']\n})\n@Component({\n  selector: 'bq-slider',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['debounceTime', 'disabled', 'gap', 'max', 'min', 'step', 'type', 'value', 'valueIndicator'],\n  standalone: true\n})\nexport class BqSlider {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqChange', 'bqBlur', 'bqFocus']);\n  }\n}\n\n\nexport declare interface BqSlider extends Components.BqSlider {\n  /**\n   * Handler to be called when change the value on range inputs\n   */\n  bqChange: EventEmitter<CustomEvent<{ value: number | Array<number> | string; el: HTMLBqSliderElement }>>;\n  /**\n   * Handler to be called when the slider loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqSliderElement>>;\n  /**\n   * Handler to be called when the slider gets focused\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqSliderElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSpinner,\n  inputs: ['animation', 'size', 'textPosition']\n})\n@Component({\n  selector: 'bq-spinner',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['animation', 'size', 'textPosition'],\n  standalone: true\n})\nexport class BqSpinner {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqSpinner extends Components.BqSpinner {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqStatus,\n  inputs: ['type']\n})\n@Component({\n  selector: 'bq-status',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['type'],\n  standalone: true\n})\nexport class BqStatus {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqStatus extends Components.BqStatus {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqStepItem,\n  inputs: ['size', 'status', 'type']\n})\n@Component({\n  selector: 'bq-step-item',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['size', 'status', 'type'],\n  standalone: true\n})\nexport class BqStepItem {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqClick']);\n  }\n}\n\n\nexport declare interface BqStepItem extends Components.BqStepItem {\n\n  bqClick: EventEmitter<CustomEvent<{ target: HTMLBqStepItemElement; value: string }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSteps,\n  inputs: ['dividerColor', 'size', 'type']\n})\n@Component({\n  selector: 'bq-steps',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['dividerColor', 'size', 'type'],\n  standalone: true\n})\nexport class BqSteps {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqSteps extends Components.BqSteps {}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqSwitch,\n  inputs: ['backgroundOnHover', 'checked', 'disabled', 'fullWidth', 'innerLabel', 'justifyContent', 'name', 'required', 'reverseOrder', 'value'],\n  methods: ['vClick', 'vFocus', 'vBlur']\n})\n@Component({\n  selector: 'bq-switch',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['backgroundOnHover', 'checked', 'disabled', 'fullWidth', 'innerLabel', 'justifyContent', 'name', 'required', 'reverseOrder', 'value'],\n  standalone: true\n})\nexport class BqSwitch {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqChange', 'bqFocus', 'bqBlur']);\n  }\n}\n\n\nexport declare interface BqSwitch extends Components.BqSwitch {\n  /**\n   * Handler to be called when the switch state changes\n   */\n  bqChange: EventEmitter<CustomEvent<{ checked: boolean }>>;\n  /**\n   * Handler to be called when the switch gets focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqSwitchElement>>;\n  /**\n   * Handler to be called when the switch loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqSwitchElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqTab,\n  inputs: ['active', 'controls', 'disabled', 'size', 'tabId'],\n  methods: ['vClick', 'vFocus', 'vBlur', 'enableFocus']\n})\n@Component({\n  selector: 'bq-tab',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['active', 'controls', 'disabled', 'size', 'tabId'],\n  standalone: true\n})\nexport class BqTab {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqClick', 'bqFocus', 'bqBlur', 'bqKeyDown']);\n  }\n}\n\n\nexport declare interface BqTab extends Components.BqTab {\n  /**\n   * Handler to be called when the tab state changes\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqTabElement>>;\n  /**\n   * Handler to be called when the tab gets focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqTabElement>>;\n  /**\n   * Handler to be called when the tab loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqTabElement>>;\n  /**\n   * Handler to be called when the tab key is pressed\n   */\n  bqKeyDown: EventEmitter<CustomEvent<KeyboardEvent>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqTabGroup,\n  inputs: ['debounceTime', 'disableDivider', 'size', 'value']\n})\n@Component({\n  selector: 'bq-tab-group',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['debounceTime', 'disableDivider', 'size', 'value'],\n  standalone: true\n})\nexport class BqTabGroup {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqChange']);\n  }\n}\n\n\nexport declare interface BqTabGroup extends Components.BqTabGroup {\n  /**\n   * Handler to be called when the tab value changes\n   */\n  bqChange: EventEmitter<CustomEvent<{ target: HTMLBqTabElement; value: string }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqTag,\n  inputs: ['border', 'clickable', 'color', 'disabled', 'hidden', 'removable', 'selected', 'size', 'variant'],\n  methods: ['hide', 'show']\n})\n@Component({\n  selector: 'bq-tag',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['border', 'clickable', 'color', 'disabled', 'hidden', 'removable', 'selected', 'size', 'variant'],\n  standalone: true\n})\nexport class BqTag {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqClose', 'bqOpen', 'bqBlur', 'bqClick', 'bqFocus']);\n  }\n}\n\n\nexport declare interface BqTag extends Components.BqTag {\n  /**\n   * Callback handler to be called when the tag is close/hidden\n   */\n  bqClose: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called when the tag is not open/shown\n   */\n  bqOpen: EventEmitter<CustomEvent<any>>;\n  /**\n   * Handler to be called when tag loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqTagElement>>;\n  /**\n   * Handler to be called when tag is clicked\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqTagElement>>;\n  /**\n   * Handler to be called when tag is focused\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqTagElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqTextarea,\n  inputs: ['autoGrow', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'debounceTime', 'disableResize', 'disabled', 'form', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'rows', 'spellcheck', 'validationStatus', 'value', 'wrap']\n})\n@Component({\n  selector: 'bq-textarea',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['autoGrow', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'debounceTime', 'disableResize', 'disabled', 'form', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'rows', 'spellcheck', 'validationStatus', 'value', 'wrap'],\n  standalone: true\n})\nexport class BqTextarea {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus', 'bqInput']);\n  }\n}\n\n\nexport declare interface BqTextarea extends Components.BqTextarea {\n  /**\n   * Callback handler emitted when the textarea loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqTextareaElement>>;\n  /**\n   * Callback handler emitted when the textarea value has changed and the textarea loses focus.\nThis handler is called whenever the user finishes typing or pasting text into the textarea field and then clicks outside of the textarea field.\n   */\n  bqChange: EventEmitter<CustomEvent<{ value: string; el: HTMLBqTextareaElement }>>;\n  /**\n   * Callback handler emitted when the textarea value has been cleared\n   */\n  bqClear: EventEmitter<CustomEvent<HTMLBqTextareaElement>>;\n  /**\n   * Callback handler emitted when the textarea has received focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqTextareaElement>>;\n  /**\n   * Callback handler emitted when the textarea value changes.\nThis handler is called whenever the user types or pastes text into the textarea field.\n   */\n  bqInput: EventEmitter<CustomEvent<{ value: string; el: HTMLBqTextareaElement }>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqToast,\n  inputs: ['border', 'hideIcon', 'open', 'placement', 'time', 'type'],\n  methods: ['show', 'hide', 'toast']\n})\n@Component({\n  selector: 'bq-toast',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['border', 'hideIcon', 'open', 'placement', 'time', 'type'],\n  standalone: true\n})\nexport class BqToast {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqHide', 'bqShow']);\n  }\n}\n\n\nexport declare interface BqToast extends Components.BqToast {\n  /**\n   * Callback handler to be called when the notification is hidden\n   */\n  bqHide: EventEmitter<CustomEvent<HTMLBqToastElement>>;\n  /**\n   * Callback handler to be called when the notification is shown\n   */\n  bqShow: EventEmitter<CustomEvent<HTMLBqToastElement>>;\n}\n\n\n@ProxyCmp({\n  defineCustomElementFn: defineBqTooltip,\n  inputs: ['alwaysVisible', 'displayOn', 'distance', 'hideArrow', 'placement', 'sameWidth', 'visible'],\n  methods: ['show', 'hide']\n})\n@Component({\n  selector: 'bq-tooltip',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['alwaysVisible', 'displayOn', 'distance', 'hideArrow', 'placement', 'sameWidth', 'visible'],\n  standalone: true\n})\nexport class BqTooltip {\n  protected el: HTMLElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqTooltip extends Components.BqTooltip {}\n\n\n"]}