@beeq/angular 1.8.0 → 1.8.1

package/esm2022/directives/components.mjs

@@ -0,0 +1,2705 @@
+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 * as i0 from "@angular/core";
+let BqAccordion = class BqAccordion {
+    /**
+   * The appearance style of the Accordion
+   */
+    set appearance(_) { }
+    ;
+    /**
+   * If true, the Accordion is disabled
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If true, the Accordion is expanded
+   */
+    set expanded(_) { }
+    ;
+    /**
+   * Animation is set through JS when the browser does not support CSS calc-size()
+If true, the Accordion animation, will be disabled. No animation will be applied.
+   */
+    set noAnimation(_) { }
+    ;
+    /**
+   * If true, the Accordion expand icon is rotate 180deg when expanded
+   */
+    set rotate(_) { }
+    ;
+    /**
+   * The size of the Accordion
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqOpen', 'bqAfterOpen', 'bqClose', 'bqAfterClose', 'bqClick']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqAccordion, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqAccordion, selector: "bq-accordion", inputs: { appearance: "appearance", disabled: "disabled", expanded: "expanded", noAnimation: "noAnimation", rotate: "rotate", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqAccordion = __decorate([
+    ProxyCmp({
+        inputs: ['appearance', 'disabled', 'expanded', 'noAnimation', 'rotate', 'size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAccordion);
+export { BqAccordion };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'noAnimation', 'rotate', 'size'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqAccordionGroup = class BqAccordionGroup {
+    /**
+   * The appearance style of accordion to be applied to all accordions
+   */
+    set appearance(_) { }
+    ;
+    /**
+   * If true all accordions are expanded
+   */
+    set expandAll(_) { }
+    ;
+    /**
+   * Animation is set through JS when the browser does not support CSS calc-size()
+If true, the accordion animation, will be disabled. No animation will be applied.
+   */
+    set noAnimation(_) { }
+    ;
+    /**
+   * If true multiple accordions can be expanded at the same time
+   */
+    set multiple(_) { }
+    ;
+    /**
+   * The size of accordion to be applied to all accordions
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqAccordionGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqAccordionGroup, selector: "bq-accordion-group", inputs: { appearance: "appearance", expandAll: "expandAll", multiple: "multiple", noAnimation: "noAnimation", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqAccordionGroup = __decorate([
+    ProxyCmp({
+        inputs: ['appearance', 'expandAll', 'multiple', 'noAnimation', 'size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAccordionGroup);
+export { BqAccordionGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'noAnimation', 'size'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqAlert = class BqAlert {
+    /**
+   * If true, the alert will automatically hide after the specified amount of time
+   */
+    set autoDismiss(_) { }
+    ;
+    /**
+   * The corner radius of the alert component
+   */
+    set border(_) { }
+    ;
+    /**
+   * If true, the close button at the top right of the alert won't be shown
+   */
+    set disableClose(_) { }
+    ;
+    /**
+   * If true, the alert icon won't be shown
+   */
+    set hideIcon(_) { }
+    ;
+    /**
+   * If true, the alert will be shown
+   */
+    set open(_) { }
+    ;
+    /**
+   * The length of time, in milliseconds, after which the alert will close itself. Only valid if `autoDismiss="true"`
+   */
+    set time(_) { }
+    ;
+    /**
+   * Type of Alert
+   */
+    set type(_) { }
+    ;
+    /**
+   * If true, the alert component will remain fixed at the top of the page, occupying the full viewport
+   */
+    set sticky(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterShow', 'bqAfterHide']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqAlert, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqAlert, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqAvatar = class BqAvatar {
+    /**
+   * Alternate text for the avatar image if the image cannot be displayed
+   */
+    set altText(_) { }
+    ;
+    /**
+   * The image source to load on the avatar (this can be also a base64 encoded image)
+   */
+    set image(_) { }
+    ;
+    /**
+   * A text to use for describing the avatar on assistive devices
+   */
+    set label(_) { }
+    ;
+    /**
+   * The text to display on avatar
+   */
+    set initials(_) { }
+    ;
+    /**
+   * The shape of the avatar
+   */
+    set shape(_) { }
+    ;
+    /**
+   * The size of the avatar
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqAvatar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqAvatar, 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({
+        inputs: ['altText', 'image', 'initials', 'label', 'shape', 'size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqAvatar);
+export { BqAvatar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqBadge = class BqBadge {
+    /**
+   * Badge background color. The value should be a valid value of the palette color
+   */
+    set backgroundColor(_) { }
+    ;
+    /**
+   * Badge number color. The value should be a valid value of the palette color
+   */
+    set textColor(_) { }
+    ;
+    /**
+   * The size of the badge. Relevant if badge has no content.
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqBadge, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqBadge, 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({
+        inputs: ['backgroundColor', 'size', 'textColor']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqBadge);
+export { BqBadge };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqBreadcrumb = class BqBreadcrumb {
+    /**
+   * The `aria-label` attribute to describe the type of navigation
+   */
+    set label(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqBreadcrumb, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqBreadcrumb, selector: "bq-breadcrumb", inputs: { label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqBreadcrumb = __decorate([
+    ProxyCmp({
+        inputs: ['label']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqBreadcrumb);
+export { BqBreadcrumb };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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: ['label'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqBreadcrumbItem = class BqBreadcrumbItem {
+    /**
+   * If set, the breadcrumb item will be rendered as an `<a>` with this `href`, otherwise, a `<button>` will be rendered.
+   */
+    set href(_) { }
+    ;
+    /**
+   * Where to display the link in the browser context. Relevant only if `href` is set.
+   */
+    set target(_) { }
+    ;
+    /**
+   * Where to display the link in the browser context. Relevant only if `href` is set.
+   */
+    set rel(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqBreadcrumbItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqBreadcrumbItem, selector: "bq-breadcrumb-item", inputs: { href: "href", rel: "rel", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqBreadcrumbItem = __decorate([
+    ProxyCmp({
+        inputs: ['href', 'rel', 'target']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqBreadcrumbItem);
+export { BqBreadcrumbItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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: ['href', 'rel', 'target'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqButton = class BqButton {
+    /**
+   * The appearance style to apply to the button
+   */
+    set appearance(_) { }
+    ;
+    /**
+   * If `true`, it will make the button fit to its parent width.
+   */
+    set block(_) { }
+    ;
+    /**
+   * The corner radius of the button
+   */
+    set border(_) { }
+    ;
+    /**
+   * If true, the button will be disabled (no interaction allowed)
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * Tells the browser to treat the linked URL as a download. Only used when `href` is set.
+Details: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-download
+   */
+    set download(_) { }
+    ;
+    /**
+   * When set, the underlying button will be rendered as an `<a>` with this `href` instead of a `<button>`
+   */
+    set href(_) { }
+    ;
+    /**
+   * It determinate how the content should be aligned
+   */
+    set justifyContent(_) { }
+    ;
+    /**
+   * If `true` it will display the button in a loading state
+   */
+    set loading(_) { }
+    ;
+    /**
+   * The size of the button
+   */
+    set size(_) { }
+    ;
+    /**
+   * Where to display the linked URL, as the name for a browsing context (a `tab`, `window`, or `<iframe>`)
+Details: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-target
+   */
+    set target(_) { }
+    ;
+    /**
+   * The default behavior of the button
+   */
+    set type(_) { }
+    ;
+    /**
+   * The variant of button to apply on top of the appearance (applicable only to `appearance="primary"`)
+   */
+    set variant(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqButton, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqCard = class BqCard {
+    /**
+   * Type of card component
+   */
+    set type(_) { }
+    ;
+    /**
+   * The corner radius of the card component
+   */
+    set border(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqCard, selector: "bq-card", inputs: { border: "border", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqCard = __decorate([
+    ProxyCmp({
+        inputs: ['border', 'type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqCard);
+export { BqCard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqCheckbox = class BqCheckbox {
+    /**
+   * If true checkbox displays background on hover
+   */
+    set backgroundOnHover(_) { }
+    ;
+    /**
+   * The form ID that the checkbox is associated with
+   */
+    set formId(_) { }
+    ;
+    /**
+   * The native form validation message
+   */
+    set formValidationMessage(_) { }
+    ;
+    /**
+   * If true checkbox is checked
+   */
+    set checked(_) { }
+    ;
+    /**
+   * If true checkbox is disabled
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * A state that is neither checked nor unchecked
+   */
+    set indeterminate(_) { }
+    ;
+    /**
+   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.
+   */
+    set name(_) { }
+    ;
+    /**
+   * If `true`, it will indicate that the user must specify a value for the checkbox before the owning form can be submitted
+   */
+    set required(_) { }
+    ;
+    /**
+   * A string representing the value of the checkbox. Primarily used to differentiate a list of related checkboxes that have the same name.
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange', 'bqFocus', 'bqBlur']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqCheckbox, selector: "bq-checkbox", inputs: { backgroundOnHover: "backgroundOnHover", checked: "checked", disabled: "disabled", formId: "formId", formValidationMessage: "formValidationMessage", indeterminate: "indeterminate", name: "name", required: "required", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqCheckbox = __decorate([
+    ProxyCmp({
+        inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'formValidationMessage', 'indeterminate', 'name', 'required', 'value'],
+        methods: ['vClick', 'vFocus', 'vBlur']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqCheckbox);
+export { BqCheckbox };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'formValidationMessage', 'indeterminate', 'name', 'required', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDatePicker = class BqDatePicker {
+    /**
+   * If `true`, the Date picker input will be focused on component render
+   */
+    set autofocus(_) { }
+    ;
+    /**
+   * The clear button aria label
+   */
+    set clearButtonLabel(_) { }
+    ;
+    /**
+   * If `true`, the clear button won't be displayed
+   */
+    set disableClear(_) { }
+    ;
+    /**
+   * Indicates whether the Date picker input is disabled or not.
+If `true`, the Date picker is disabled and cannot be interacted with.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * Represents the distance (gutter or margin) between the Date picker panel and the input element.
+   */
+    set distance(_) { }
+    ;
+    /**
+   * The first day of the week, where Sunday is 0, Monday is 1, etc
+   */
+    set firstDayOfWeek(_) { }
+    ;
+    /**
+   * The options to use when formatting the displayed value.
+Details: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat#using_options
+   */
+    set formatOptions(_) { }
+    ;
+    /**
+   * The ID of the form that the Date picker input belongs to.
+   */
+    set form(_) { }
+    ;
+    /**
+   * The native form validation message (mandatory if `required` is set)
+   */
+    set formValidationMessage(_) { }
+    ;
+    /**
+   * A function that takes a date and returns true if the date should not be selectable
+   */
+    set isDateDisallowed(_) { }
+    ;
+    /**
+   * The locale for formatting dates. If not set, will use the browser's locale.
+Details: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument
+   */
+    set locale(_) { }
+    ;
+    /**
+   * The latest date that can be selected
+   */
+    set max(_) { }
+    ;
+    /**
+   * The earliest date that can be selected
+   */
+    set min(_) { }
+    ;
+    /**
+   * Number of months to show when range is `true`
+   */
+    set months(_) { }
+    ;
+    /**
+   * Specifies how the next/previous buttons should navigate the calendar.
+- single: The buttons will navigate by a single month at a time.
+- months: The buttons will navigate by the number of months displayed per view.
+   */
+    set monthsPerView(_) { }
+    ;
+    /**
+   * The Date picker input name.
+   */
+    set name(_) { }
+    ;
+    /**
+   * If `true`, the Date picker panel will be visible.
+   */
+    set open(_) { }
+    ;
+    /**
+   * When set, it will override the height of the Date picker panel.
+   */
+    set panelHeight(_) { }
+    ;
+    /**
+   * The Date picker input placeholder text value
+   */
+    set placeholder(_) { }
+    ;
+    /**
+   * Position of the Date picker panel
+   */
+    set placement(_) { }
+    ;
+    /**
+   * Indicates whether or not the Date picker input is required to be filled out before submitting the form.
+   */
+    set required(_) { }
+    ;
+    /**
+   * Represents the skidding between the Date picker panel and the input element.
+   */
+    set skidding(_) { }
+    ;
+    /**
+   * Whether to show days outside the month
+   */
+    set showOutsideDays(_) { }
+    ;
+    /**
+   * Defines the strategy to position the Date picker panel
+   */
+    set strategy(_) { }
+    ;
+    /**
+   * The date that is tentatively selected e.g. the start of a range selection
+   */
+    set tentative(_) { }
+    ;
+    /**
+   * It defines how the calendar will behave, allowing single date selection, range selection, or multiple date selection
+   */
+    set type(_) { }
+    ;
+    /**
+   * The validation status of the Select input. @remarks This property is used to indicate the validation status of the select input. It can be set to one of the following values:
+- `'none'`: No validation status is set.
+- `'error'`: The input has a validation error.
+- `'warning'`: The input has a validation warning.
+- `'success'`: The input has passed validation.
+   */
+    set validationStatus(_) { }
+    ;
+    /**
+   * The select input value represents the currently selected date or range and can be used to reset the field to a previous value.
+All dates are expected in ISO-8601 format (YYYY-MM-DD).
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqDatePicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqDatePicker, selector: "bq-date-picker", inputs: { autofocus: "autofocus", clearButtonLabel: "clearButtonLabel", disableClear: "disableClear", disabled: "disabled", distance: "distance", firstDayOfWeek: "firstDayOfWeek", form: "form", formValidationMessage: "formValidationMessage", formatOptions: "formatOptions", isDateDisallowed: "isDateDisallowed", locale: "locale", max: "max", min: "min", months: "months", monthsPerView: "monthsPerView", name: "name", open: "open", panelHeight: "panelHeight", placeholder: "placeholder", placement: "placement", required: "required", showOutsideDays: "showOutsideDays", skidding: "skidding", strategy: "strategy", tentative: "tentative", type: "type", validationStatus: "validationStatus", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqDatePicker = __decorate([
+    ProxyCmp({
+        inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'firstDayOfWeek', 'form', 'formValidationMessage', 'formatOptions', 'isDateDisallowed', 'locale', 'max', 'min', 'months', 'monthsPerView', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'required', 'showOutsideDays', 'skidding', 'strategy', 'tentative', 'type', 'validationStatus', 'value'],
+        methods: ['clear']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqDatePicker);
+export { BqDatePicker };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqDatePicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-date-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'firstDayOfWeek', 'form', 'formValidationMessage', 'formatOptions', 'isDateDisallowed', 'locale', 'max', 'min', 'months', 'monthsPerView', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'required', 'showOutsideDays', 'skidding', 'strategy', 'tentative', 'type', 'validationStatus', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDialog = class BqDialog {
+    /**
+   * Border radius of the dialog component
+   */
+    set border(_) { }
+    ;
+    /**
+   * If true, the backdrop overlay won't be shown when the dialog opens
+   */
+    set disableBackdrop(_) { }
+    ;
+    /**
+   * If true, the dialog will not close when the [Esc] key is press
+   */
+    set disableCloseEscKeydown(_) { }
+    ;
+    /**
+   * If true, the dialog will not close when clicking on the backdrop overlay
+   */
+    set disableCloseClickOutside(_) { }
+    ;
+    /**
+   * The appearance of footer
+   */
+    set footerAppearance(_) { }
+    ;
+    /**
+   * If true, it hides the close button
+   */
+    set hideCloseButton(_) { }
+    ;
+    /**
+   * If true, the dialog will be shown as open
+   */
+    set open(_) { }
+    ;
+    /**
+   * The size of the dialog
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqCancel', 'bqClose', 'bqOpen', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqDialog, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqDialog, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDivider = class BqDivider {
+    /**
+   * If true, the divider has a dashed pattern
+   */
+    set dashed(_) { }
+    ;
+    /**
+   * The default orientation of the divider
+   */
+    set orientation(_) { }
+    ;
+    /**
+   * Set the stroke color of the divider. The value should be a valid value of the palette color
+   */
+    set strokeColor(_) { }
+    ;
+    /**
+   * Set the alignment of the title on the main axis of the divider (horizontal / vertical)
+   */
+    set titleAlignment(_) { }
+    ;
+    /**
+   * Set the width of each dash of the divider's stroke. This is applicable when the stroke is dashed
+   */
+    set strokeDashWidth(_) { }
+    ;
+    /**
+   * Set the gap of the divider's stroke. This is applicable when the stroke is dashed
+   */
+    set strokeDashGap(_) { }
+    ;
+    /**
+   * Set the thickness of the divider's stroke. Value expressed in px
+   */
+    set strokeThickness(_) { }
+    ;
+    /**
+   * Set the min width of the divider's stroke when text is not centered. Value expressed in px
+   */
+    set strokeBasis(_) { }
+    ;
+    /**
+   * Set the line of the divider's stroke. This is applicable when the stroke is dashed
+   */
+    set strokeLinecap(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqDivider, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDrawer = class BqDrawer {
+    /**
+   * If true, the backdrop overlay will be shown when the drawer opens
+   */
+    set enableBackdrop(_) { }
+    ;
+    /**
+   * If true, the drawer will not close when clicking outside the panel
+   */
+    set closeOnClickOutside(_) { }
+    ;
+    /**
+   * If true, the dialog will not close when the [Esc] key is pressed
+   */
+    set closeOnEsc(_) { }
+    ;
+    /**
+   * If true, the drawer component will be shown
+   */
+    set open(_) { }
+    ;
+    /**
+   *  @deprecated Defines the position of the drawer
+   */
+    set placement(_) { }
+    ;
+    /**
+   * Defines the position of the drawer
+   */
+    set position(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClose', 'bqOpen', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqDrawer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqDrawer, selector: "bq-drawer", inputs: { closeOnClickOutside: "closeOnClickOutside", closeOnEsc: "closeOnEsc", enableBackdrop: "enableBackdrop", open: "open", placement: "placement", position: "position" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqDrawer = __decorate([
+    ProxyCmp({
+        inputs: ['closeOnClickOutside', 'closeOnEsc', 'enableBackdrop', 'open', 'placement', 'position'],
+        methods: ['hide', 'show']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqDrawer);
+export { BqDrawer };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'position'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqDropdown = class BqDropdown {
+    /**
+   * If true, the dropdown panel will be visible and won't be shown.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * Represents the distance (gutter or margin) between the panel and the trigger element.
+   */
+    set distance(_) { }
+    ;
+    /**
+   * If true, the panel will remain open after a selection is made.
+   */
+    set keepOpenOnSelect(_) { }
+    ;
+    /**
+   * Position of the panel
+   */
+    set placement(_) { }
+    ;
+    /**
+   * If true, the panel will be visible.
+   */
+    set open(_) { }
+    ;
+    /**
+   * When set, it will override the height of the dropdown panel
+   */
+    set panelHeight(_) { }
+    ;
+    /**
+   * Whether the panel should have the same width as the trigger element
+   */
+    set sameWidth(_) { }
+    ;
+    /**
+   * Represents the skidding between the panel and the trigger element.
+   */
+    set skidding(_) { }
+    ;
+    /**
+   * Defines the strategy to position the panel
+   */
+    set strategy(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqOpen']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqDropdown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqDropdown, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqEmptyState = class BqEmptyState {
+    /**
+   * The size of the empty state component
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqEmptyState, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqEmptyState, selector: "bq-empty-state", inputs: { size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqEmptyState = __decorate([
+    ProxyCmp({
+        inputs: ['size']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqEmptyState);
+export { BqEmptyState };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqIcon = class BqIcon {
+    /**
+   * Label for the icon, used for accessibility
+   */
+    set label(_) { }
+    ;
+    /**
+   * Set the stroke color of the SVG. The value should be a valid value of the palette color
+   */
+    set color(_) { }
+    ;
+    /**
+   * Icon name to load. Please check all available icons [here](https://phosphoricons.com/)
+   */
+    set name(_) { }
+    ;
+    /**
+   * Set the size of the SVG
+   */
+    set size(_) { }
+    ;
+    /**
+   * Set the source of the SVG. If the source is set, the name property will be ignored
+   */
+    set src(_) { }
+    ;
+    /**
+   *  @deprecated It set the icon weight/style
+   */
+    set weight(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['svgLoaded']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqIcon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqIcon, 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({
+        inputs: ['color', 'label', 'name', 'size', 'src', 'weight']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqIcon);
+export { BqIcon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqInput = class BqInput {
+    /**
+   * Controls whether or not the input field should be capitalized and how.
+Possible values are 'off', 'none', 'on', 'sentences', 'words', and 'characters'.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize
+   */
+    set autocapitalize(_) { }
+    ;
+    /**
+   * Specifies whether or not the input field should have autocomplete enabled.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values
+   */
+    set autocomplete(_) { }
+    ;
+    /**
+   * Controls whether or not the input field should have autocorrect enabled.
+Possible values are 'on' and 'off'.
+   */
+    set autocorrect(_) { }
+    ;
+    /**
+   * If true, the input will be focused on component render
+   */
+    set autofocus(_) { }
+    ;
+    /**
+   * The clear button aria label
+   */
+    set clearButtonLabel(_) { }
+    ;
+    /**
+   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the input value changes.
+A value of 0 means no debouncing will occur.
+   */
+    set debounceTime(_) { }
+    ;
+    /**
+   * Indicates whether the input is disabled or not.
+If `true`, the input is disabled and cannot be interacted with.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If true, the clear button won't be displayed
+   */
+    set disableClear(_) { }
+    ;
+    /**
+   * The ID of the form that the input field belongs to.
+   */
+    set form(_) { }
+    ;
+    /**
+   * The native form validation message (mandatory if `required` is set)
+   */
+    set formValidationMessage(_) { }
+    ;
+    /**
+   * The inputmode attribute specifies what kind of input mechanism would be most helpful for users entering content into the input field.
+This allows a browser to display an appropriate virtual keyboard while editing.
+Possible values are 'none', 'text', 'decimal', 'numeric', 'tel', 'search', 'email', 'url', and 'date'.
+   */
+    set inputmode(_) { }
+    ;
+    /**
+   * The maximum value that the input field can accept.
+Only applies to date and number input types.
+   */
+    set max(_) { }
+    ;
+    /**
+   * The maximum number of characters that the input field can accept.
+   */
+    set maxlength(_) { }
+    ;
+    /**
+   * The minimum value that the input field can accept.
+Only applies to date and number input types.
+   */
+    set min(_) { }
+    ;
+    /**
+   * The minimum number of characters that the input field can accept.
+   */
+    set minlength(_) { }
+    ;
+    /**
+   * The input field name.
+   */
+    set name(_) { }
+    ;
+    /**
+   * Specifies a regular expression the form control's value should match.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/pattern
+   */
+    set pattern(_) { }
+    ;
+    /**
+   * The input placeholder text value
+   */
+    set placeholder(_) { }
+    ;
+    /**
+   * If true, the input field cannot be modified.
+   */
+    set readonly(_) { }
+    ;
+    /**
+   * Indicates whether or not the input field is required to be filled out before submitting the form.
+   */
+    set required(_) { }
+    ;
+    /**
+   * A number that specifies the granularity that the value must adhere to.
+Valid for date, month, week, time, datetime-local, number, and range.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#step
+   */
+    set step(_) { }
+    ;
+    /**
+   * The type attribute specifies the type of input field to display.
+Possible values are 'text', 'password', 'email', 'number', 'tel', 'search', 'url', and more.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#input_types
+   */
+    set type(_) { }
+    ;
+    /**
+   * The validation status of the input. @remarks This property is used to indicate the validation status of the input. It can be set to one of the following values:
+- `'none'`: No validation status is set.
+- `'error'`: The input has a validation error.
+- `'warning'`: The input has a validation warning.
+- `'success'`: The input has passed validation.
+   */
+    set validationStatus(_) { }
+    ;
+    /**
+   * The input value, it can be used to reset the input to a previous value
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus', 'bqInput']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqInput, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqInput, selector: "bq-input", inputs: { autocapitalize: "autocapitalize", autocomplete: "autocomplete", autocorrect: "autocorrect", autofocus: "autofocus", clearButtonLabel: "clearButtonLabel", debounceTime: "debounceTime", disableClear: "disableClear", disabled: "disabled", form: "form", formValidationMessage: "formValidationMessage", 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({
+        inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'form', 'formValidationMessage', '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: "18.2.13", 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', 'formValidationMessage', 'inputmode', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'step', 'type', 'validationStatus', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqNotification = class BqNotification {
+    /**
+   * If true, the notification will automatically hide after the specified amount of time
+   */
+    set autoDismiss(_) { }
+    ;
+    /**
+   * The corder radius of the notification component
+   */
+    set border(_) { }
+    ;
+    /**
+   * If true, the close button at the top right of the notification won't be shown
+   */
+    set disableClose(_) { }
+    ;
+    /**
+   * If true, the notification icon won't be shown
+   */
+    set hideIcon(_) { }
+    ;
+    /**
+   * If true, the notification will be shown
+   */
+    set open(_) { }
+    ;
+    /**
+   * The length of time, in milliseconds, after which the notification will close itself. Only valid if `autoDismiss="true"`
+   */
+    set time(_) { }
+    ;
+    /**
+   * Type of Notification
+   */
+    set type(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterOpen', 'bqAfterClose']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqNotification, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqNotification, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqOption = class BqOption {
+    /**
+   * If true, the option is hidden.
+   */
+    set hidden(_) { }
+    ;
+    /**
+   * If true, the option is disabled.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * A string representing the value of the option. Can be used to identify the item
+   */
+    set value(_) { }
+    ;
+    /**
+   * If true, the option is selected and active.
+   */
+    set selected(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick', 'bqEnter']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqOption, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqOption, selector: "bq-option", inputs: { disabled: "disabled", hidden: "hidden", selected: "selected", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqOption = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'hidden', 'selected', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqOption);
+export { BqOption };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'hidden', 'selected', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqOptionGroup = class BqOptionGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqOptionGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqOptionGroup, selector: "bq-option-group", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqOptionGroup = __decorate([
+    ProxyCmp({}),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqOptionGroup);
+export { BqOptionGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqOptionList = class BqOptionList {
+    /**
+   * Aria label for the list.
+   */
+    set ariaLabel(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqSelect']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqOptionList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqOptionList, selector: "bq-option-list", inputs: { ariaLabel: "ariaLabel" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqOptionList = __decorate([
+    ProxyCmp({
+        inputs: ['ariaLabel']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqOptionList);
+export { BqOptionList };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqPageTitle = class BqPageTitle {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqPageTitle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqPageTitle, selector: "bq-page-title", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqPageTitle = __decorate([
+    ProxyCmp({}),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqPageTitle);
+export { BqPageTitle };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqPageTitle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bq-page-title',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqPanel = class BqPanel {
+    /**
+   * Represents the distance (gutter or margin) between the panel and the trigger element.
+   */
+    set distance(_) { }
+    ;
+    /**
+   * Position of the panel
+   */
+    set placement(_) { }
+    ;
+    /**
+   * If true, the panel will be visible.
+   */
+    set open(_) { }
+    ;
+    /**
+   * Whether the panel should have the same width as the trigger element
+   */
+    set sameWidth(_) { }
+    ;
+    /**
+   * Represents the skidding between the panel and the trigger element.
+   */
+    set skidding(_) { }
+    ;
+    /**
+   * Defines the strategy to position the panel
+   */
+    set strategy(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqPanel, 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({
+        inputs: ['distance', 'open', 'placement', 'sameWidth', 'skidding', 'strategy']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqPanel);
+export { BqPanel };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqProgress = class BqProgress {
+    /**
+   * It will set the border style of the progress bar
+   */
+    set borderShape(_) { }
+    ;
+    /**
+   * If `true`, a tooltip will be shown displaying the progress value
+   */
+    set enableTooltip(_) { }
+    ;
+    /**
+   * If `true` the indeterminate state of progress bar is enabled
+   */
+    set indeterminate(_) { }
+    ;
+    /**
+   * If `true, a label text showing the value (in percentage) will be shown
+   */
+    set label(_) { }
+    ;
+    /**
+   * Progress bar thickness
+   */
+    set thickness(_) { }
+    ;
+    /**
+   * Progress type
+   */
+    set type(_) { }
+    ;
+    /**
+   * A number representing the current value of the progress bar
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqProgress, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqProgress, 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({
+        inputs: ['borderShape', 'enableTooltip', 'indeterminate', 'label', 'thickness', 'type', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqProgress);
+export { BqProgress };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqRadio = class BqRadio {
+    /**
+   * If true radio input is checked
+   */
+    set checked(_) { }
+    ;
+    /**
+   * If true radio input is disabled
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If true radio displays background on hover
+   */
+    set backgroundOnHover(_) { }
+    ;
+    /**
+   * The form ID that the radio input is associated with
+   */
+    set formId(_) { }
+    ;
+    /**
+   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.
+   */
+    set name(_) { }
+    ;
+    /**
+   * If `true`, it will indicate that the user must specify a value for the radio before the owning form can be submitted
+   */
+    set required(_) { }
+    ;
+    /**
+   * A string representing the value of the radio.
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClick', 'bqFocus', 'bqBlur', 'bqKeyDown']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqRadio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqRadio, 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({
+        inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'name', 'required', 'value'],
+        methods: ['vClick', 'vFocus', 'vBlur', 'getNativeInput']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqRadio);
+export { BqRadio };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqRadioGroup = class BqRadioGroup {
+    /**
+   * If true, all radio inputs in the group will display a background on hover
+   */
+    set backgroundOnHover(_) { }
+    ;
+    /**
+   * A number representing the delay time (in milliseconds) that `bqChange` event handler gets triggered once the value change
+   */
+    set debounceTime(_) { }
+    ;
+    /**
+   * If true radio inputs are disabled
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If true displays fieldset
+   */
+    set fieldset(_) { }
+    ;
+    /**
+   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.
+   */
+    set name(_) { }
+    ;
+    /**
+   * The display orientation of the radio inputs
+   */
+    set orientation(_) { }
+    ;
+    /**
+   * If true, the radio group is required
+   */
+    set required(_) { }
+    ;
+    /**
+   * The native form validation message when the radio group is required
+   */
+    set requiredValidationMessage(_) { }
+    ;
+    /**
+   * A string representing the value of the radio.
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqRadioGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqRadioGroup, selector: "bq-radio-group", inputs: { backgroundOnHover: "backgroundOnHover", debounceTime: "debounceTime", disabled: "disabled", fieldset: "fieldset", name: "name", orientation: "orientation", required: "required", requiredValidationMessage: "requiredValidationMessage", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqRadioGroup = __decorate([
+    ProxyCmp({
+        inputs: ['backgroundOnHover', 'debounceTime', 'disabled', 'fieldset', 'name', 'orientation', 'required', 'requiredValidationMessage', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqRadioGroup);
+export { BqRadioGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'required', 'requiredValidationMessage', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSelect = class BqSelect {
+    /**
+   * If true, the Select input will be focused on component render
+   */
+    set autofocus(_) { }
+    ;
+    /**
+   * The clear button aria label
+   */
+    set clearButtonLabel(_) { }
+    ;
+    /**
+   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the input value changes.
+A value of 0 means no debouncing will occur.
+   */
+    set debounceTime(_) { }
+    ;
+    /**
+   * Indicates whether the Select input is disabled or not.
+If `true`, the Select is disabled and cannot be interacted with.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If true, the clear button won't be displayed
+   */
+    set disableClear(_) { }
+    ;
+    /**
+   * Represents the distance (gutter or margin) between the Select panel and the input element.
+   */
+    set distance(_) { }
+    ;
+    /**
+   * The ID of the form that the Select input belongs to.
+   */
+    set form(_) { }
+    ;
+    /**
+   * If true, the Select panel will remain open after a selection is made.
+   */
+    set keepOpenOnSelect(_) { }
+    ;
+    /**
+   * The Select input name.
+   */
+    set name(_) { }
+    ;
+    /**
+   * The maximum number of tags to display when multiple selection is enabled
+   */
+    set maxTagsVisible(_) { }
+    ;
+    /**
+   * If true, the Select input will allow multiple selections.
+   */
+    set multiple(_) { }
+    ;
+    /**
+   * If true, the Select panel will be visible.
+   */
+    set open(_) { }
+    ;
+    /**
+   * When set, it will override the height of the Select panel.
+   */
+    set panelHeight(_) { }
+    ;
+    /**
+   * The Select input placeholder text value
+   */
+    set placeholder(_) { }
+    ;
+    /**
+   * Position of the Select panel
+   */
+    set placement(_) { }
+    ;
+    /**
+   * If true, the list of options cannot be filtered (searching won't be available)
+   */
+    set readonly(_) { }
+    ;
+    /**
+   * Indicates whether or not the Select input is required to be filled out before submitting the form.
+   */
+    set required(_) { }
+    ;
+    /**
+   * Whether the panel should have the Select same width as the input element
+   */
+    set sameWidth(_) { }
+    ;
+    /**
+   * Represents the skidding between the Select panel and the input element.
+   */
+    set skidding(_) { }
+    ;
+    /**
+   * Defines the strategy to position the Select panel
+   */
+    set strategy(_) { }
+    ;
+    /**
+   * The validation status of the Select input. @remarks This property is used to indicate the validation status of the select input. It can be set to one of the following values:
+- `'none'`: No validation status is set.
+- `'error'`: The input has a validation error.
+- `'warning'`: The input has a validation warning.
+- `'success'`: The input has passed validation.
+   */
+    set validationStatus(_) { }
+    ;
+    /**
+   * The select input value, it can be used to reset the field to a previous value
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqClear', 'bqFocus', 'bqSelect']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSelect, selector: "bq-select", inputs: { autofocus: "autofocus", clearButtonLabel: "clearButtonLabel", debounceTime: "debounceTime", disableClear: "disableClear", disabled: "disabled", distance: "distance", form: "form", keepOpenOnSelect: "keepOpenOnSelect", maxTagsVisible: "maxTagsVisible", multiple: "multiple", 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({
+        inputs: ['autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'maxTagsVisible', 'multiple', '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: "18.2.13", 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', 'debounceTime', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'maxTagsVisible', 'multiple', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'readonly', 'required', 'sameWidth', 'skidding', 'strategy', 'validationStatus', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSideMenu = class BqSideMenu {
+    /**
+   * It sets a predefined appearance of the side menu
+   */
+    set appearance(_) { }
+    ;
+    /**
+   * If true, the container will reduce its width
+   */
+    set collapse(_) { }
+    ;
+    /**
+   * It sets the size of the navigation menu items
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqCollapse', 'bqSelect']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSideMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSideMenu, 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({
+        inputs: ['appearance', 'collapse', 'size'],
+        methods: ['toggleCollapse']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSideMenu);
+export { BqSideMenu };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSideMenuItem = class BqSideMenuItem {
+    /**
+   * If true, the menu item will be shown as active/selected.
+   */
+    set active(_) { }
+    ;
+    /**
+   * If true, the item label and suffix will be hidden and the with will be reduce according to its parent
+   */
+    set collapse(_) { }
+    ;
+    /**
+   * If true, the menu item will be disabled (no interaction allowed)
+   */
+    set disabled(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqFocus', 'bqClick']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSideMenuItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSideMenuItem, 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({
+        inputs: ['active', 'collapse', 'disabled']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSideMenuItem);
+export { BqSideMenuItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSlider = class BqSlider {
+    /**
+   * The amount of time, in milliseconds, to wait to trigger the `bqChange` event after each value change.
+   */
+    set debounceTime(_) { }
+    ;
+    /**
+   * If `true` the slider is disabled.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If `true` it will show the value label on a side of the slider track area
+   */
+    set enableValueIndicator(_) { }
+    ;
+    /**
+   * A number representing the amount to remain between the minimum and maximum values (only for range type).
+   */
+    set gap(_) { }
+    ;
+    /**
+   * A number representing the max value of the slider.
+   */
+    set max(_) { }
+    ;
+    /**
+   * A number representing the min value of the slider.
+   */
+    set min(_) { }
+    ;
+    /**
+   * Name of the form control. Submitted with the form as part of a name/value pair
+   */
+    set name(_) { }
+    ;
+    /**
+   * A number representing the step of the slider.
+⚠️ Please notice that the value (or list of values if the slider type is `range`) will be rounded to the nearest multiple of `step`.
+   */
+    set step(_) { }
+    ;
+    /**
+   * It defines the type of slider to display
+   */
+    set type(_) { }
+    ;
+    /**
+   * The value of the slider.
+- If the slider type is `single`, the value is a number.
+- If the slider type is `range`, the value is an array of two numbers (the first number represents the `min` value and the second number represents the `max` value).
+   */
+    set value(_) { }
+    ;
+    /**
+   * If `true`, a tooltip will be shown displaying the progress value
+   */
+    set enableTooltip(_) { }
+    ;
+    /**
+   * If `true`, a tooltip will always display the progress value.
+It relies on enableTooltip and if enableTooltip is false, tooltipAlwaysVisible cannot be true.
+   */
+    set tooltipAlwaysVisible(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange', 'bqBlur', 'bqFocus']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSlider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSlider, selector: "bq-slider", inputs: { debounceTime: "debounceTime", disabled: "disabled", enableTooltip: "enableTooltip", enableValueIndicator: "enableValueIndicator", gap: "gap", max: "max", min: "min", name: "name", step: "step", tooltipAlwaysVisible: "tooltipAlwaysVisible", type: "type", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqSlider = __decorate([
+    ProxyCmp({
+        inputs: ['debounceTime', 'disabled', 'enableTooltip', 'enableValueIndicator', 'gap', 'max', 'min', 'name', 'step', 'tooltipAlwaysVisible', 'type', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSlider);
+export { BqSlider };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'enableTooltip', 'enableValueIndicator', 'gap', 'max', 'min', 'name', 'step', 'tooltipAlwaysVisible', 'type', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSpinner = class BqSpinner {
+    /**
+   * If `false`, the animation on the icon element will be stopped
+   */
+    set animation(_) { }
+    ;
+    /**
+   * It defines the position of the label text
+   */
+    set textPosition(_) { }
+    ;
+    /**
+   * It defines the size of the icon element displayed
+   */
+    set size(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSpinner, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSpinner, 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({
+        inputs: ['animation', 'size', 'textPosition']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSpinner);
+export { BqSpinner };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqStatus = class BqStatus {
+    /**
+   * It defines the type of status to display
+   */
+    set type(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqStatus, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqStatus, selector: "bq-status", inputs: { type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqStatus = __decorate([
+    ProxyCmp({
+        inputs: ['type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqStatus);
+export { BqStatus };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqStepItem = class BqStepItem {
+    /**
+   * It defines prefix size
+   */
+    set size(_) { }
+    ;
+    /**
+   * It defines step item appearance based on its status
+   */
+    set status(_) { }
+    ;
+    /**
+   * It defines the step item type used
+   */
+    set type(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClick']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqStepItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqStepItem, 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({
+        inputs: ['size', 'status', 'type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqStepItem);
+export { BqStepItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSteps = class BqSteps {
+    /**
+   * The color of the line that connects the steps. It should be a valid declarative color token.
+   */
+    set dividerColor(_) { }
+    ;
+    /**
+   * The size of the steps
+   */
+    set size(_) { }
+    ;
+    /**
+   * The type of prefix element to use on the step items
+   */
+    set type(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSteps, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSteps, 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({
+        inputs: ['dividerColor', 'size', 'type']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqSteps);
+export { BqSteps };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqSwitch = class BqSwitch {
+    /**
+   * If true, a background will be displayed on hover
+   */
+    set backgroundOnHover(_) { }
+    ;
+    /**
+   * It indicates whether if the switch is `ON` by default (when the page loads)
+   */
+    set checked(_) { }
+    ;
+    /**
+   * If true, the switch control will be disabled and no interaction will be allowed
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * The native form validation message
+   */
+    set formValidationMessage(_) { }
+    ;
+    /**
+   * If true, the component will take the full width space available on the parent container
+   */
+    set fullWidth(_) { }
+    ;
+    /**
+   * It indicates how to to display the on/off marks inside the control, with icons or none (default)
+   */
+    set innerLabel(_) { }
+    ;
+    /**
+   * It defines how to distribute the space between and around the control and the label text
+(https://developer.mozilla.org/en-US/docs/Web/CSS/justify-content)
+   */
+    set justifyContent(_) { }
+    ;
+    /**
+   * Name of the form control. Submitted with the form as part of a name/value pair
+   */
+    set name(_) { }
+    ;
+    /**
+   * If `true`, it will indicate that the user must switch `ON` the element before the owning form can be submitted
+   */
+    set required(_) { }
+    ;
+    /**
+   * If true, the order of the control and the label text will be changed
+   */
+    set reverseOrder(_) { }
+    ;
+    /**
+   * The input control's value, submitted as a name/value pair with form data.
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange', 'bqFocus', 'bqBlur']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqSwitch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqSwitch, selector: "bq-switch", inputs: { backgroundOnHover: "backgroundOnHover", checked: "checked", disabled: "disabled", formValidationMessage: "formValidationMessage", 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({
+        inputs: ['backgroundOnHover', 'checked', 'disabled', 'formValidationMessage', '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: "18.2.13", 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', 'formValidationMessage', 'fullWidth', 'innerLabel', 'justifyContent', 'name', 'required', 'reverseOrder', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTab = class BqTab {
+    /**
+   * If true tab is active
+   */
+    set active(_) { }
+    ;
+    /**
+   * The tab panel id that the tab controls
+   */
+    set controls(_) { }
+    ;
+    /**
+   * If true tab is disabled
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * The direction that tab should be render
+   */
+    set orientation(_) { }
+    ;
+    /**
+   * The placement that tab should be render
+   */
+    set placement(_) { }
+    ;
+    /**
+   * The size of the tab
+   */
+    set size(_) { }
+    ;
+    /**
+   * The id of the tab
+   */
+    set tabId(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClick', 'bqFocus', 'bqBlur', 'bqKeyDown']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqTab, selector: "bq-tab", inputs: { active: "active", controls: "controls", disabled: "disabled", orientation: "orientation", placement: "placement", size: "size", tabId: "tabId" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqTab = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'controls', 'disabled', 'orientation', 'placement', 'size', 'tabId'],
+        methods: ['vClick', 'vFocus', 'vBlur']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTab);
+export { BqTab };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'orientation', 'placement', 'size', 'tabId'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTabGroup = class BqTabGroup {
+    /**
+   * A number representing the delay value applied to bqChange event handler
+   */
+    set debounceTime(_) { }
+    ;
+    /**
+   * If true, the underline divider below the tabs won't be shown
+   */
+    set disableDivider(_) { }
+    ;
+    /**
+   * The direction that tab should be render
+   */
+    set orientation(_) { }
+    ;
+    /**
+   * The placement that tab should be render
+   */
+    set placement(_) { }
+    ;
+    /**
+   * The size of the tab
+   */
+    set size(_) { }
+    ;
+    /**
+   * A string representing the id of the selected tab.
+   */
+    set value(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqChange']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqTabGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqTabGroup, selector: "bq-tab-group", inputs: { debounceTime: "debounceTime", disableDivider: "disableDivider", orientation: "orientation", placement: "placement", size: "size", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+};
+BqTabGroup = __decorate([
+    ProxyCmp({
+        inputs: ['debounceTime', 'disableDivider', 'orientation', 'placement', 'size', 'value']
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], BqTabGroup);
+export { BqTabGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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', 'orientation', 'placement', 'size', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTag = class BqTag {
+    /**
+   * The corner radius of the Tag (will override size's predefined border)
+   */
+    set border(_) { }
+    ;
+    /**
+   * If true, the Tag can be clickable
+   */
+    set clickable(_) { }
+    ;
+    /**
+   * The color style of the Tag
+   */
+    set color(_) { }
+    ;
+    /**
+   * If true, the Tag will be disabled (only if clickable = `true`, no interaction allowed)
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If true, the Tag component will hidden (only if removable = `true`)
+   */
+    set hidden(_) { }
+    ;
+    /**
+   * If true, the Tag component can be removed
+   */
+    set removable(_) { }
+    ;
+    /**
+   * If true, the Tag is selected (only if clickable = `true`)
+   */
+    set selected(_) { }
+    ;
+    /**
+   * The size of the Tag component
+   */
+    set size(_) { }
+    ;
+    /**
+   * The variant of Tag to apply on top of the variant
+   */
+    set variant(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqClose', 'bqOpen', 'bqBlur', 'bqClick', 'bqFocus']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqTag, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqTag, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTextarea = class BqTextarea {
+    /**
+   * Controls whether or not the textarea field should be capitalized and how.
+Possible values are 'off', 'none', 'on', 'sentences', 'words', and 'characters'.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize
+   */
+    set autocapitalize(_) { }
+    ;
+    /**
+   * Specifies whether or not the textarea field should have autocomplete enabled.
+See: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values
+   */
+    set autocomplete(_) { }
+    ;
+    /**
+   * Controls whether or not the textarea field should have autocorrect enabled.
+Possible values are 'on' and 'off'.
+   */
+    set autocorrect(_) { }
+    ;
+    /**
+   * If true, the textarea will be focused on component render
+   */
+    set autofocus(_) { }
+    ;
+    /**
+   * If `true`, the textarea will automatically grow and shrink to fit its contents.
+If `false`, the textarea will have a fixed height specified by the `rows` property.
+   */
+    set autoGrow(_) { }
+    ;
+    /**
+   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the textarea value changes.
+A value of 0 means no debouncing will occur.
+   */
+    set debounceTime(_) { }
+    ;
+    /**
+   * If `true`, the user cannot interact with the textarea.
+   */
+    set disabled(_) { }
+    ;
+    /**
+   * If `true`, it will block the user's ability to resize the textarea.
+   */
+    set disableResize(_) { }
+    ;
+    /**
+   * The ID of the form that the textarea field belongs to.
+   */
+    set form(_) { }
+    ;
+    /**
+   * The native form validation message
+   */
+    set formValidationMessage(_) { }
+    ;
+    /**
+   * The maximum number of characters that can be entered into the textarea (`0`: no limit).
+When enabled, a character counter will be shown underneath the textarea.
+   */
+    set maxlength(_) { }
+    ;
+    /**
+   * The name of the textarea element.
+   */
+    set name(_) { }
+    ;
+    /**
+   * The placeholder text to show when there is no value.
+   */
+    set placeholder(_) { }
+    ;
+    /**
+   * If true, the textarea field cannot be modified.
+   */
+    set readonly(_) { }
+    ;
+    /**
+   * Indicates whether or not the textarea field is required to be filled out before submitting the form.
+   */
+    set required(_) { }
+    ;
+    /**
+   * The number of visible text lines for the control. It must be a positive integer.
+   */
+    set rows(_) { }
+    ;
+    /**
+   * If true, the textarea content may be checked for spelling errors.
+   */
+    set spellcheck(_) { }
+    ;
+    /**
+   * The validation status of the textarea. @remarks This property is used to indicate the validation status of the textarea. It can be set to one of the following values:
+- `'none'`: No validation status is set.
+- `'error'`: The textarea has a validation error.
+- `'warning'`: The textarea has a validation warning.
+- `'success'`: The textarea has passed validation.
+   */
+    set validationStatus(_) { }
+    ;
+    /**
+   * The value of the textarea. It can be used to reset the textarea to a previous value.
+   */
+    set value(_) { }
+    ;
+    /**
+   * Specifies how the text in a text area is to be wrapped when submitted in a form
+   */
+    set wrap(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqBlur', 'bqChange', 'bqClear', 'bqFocus', 'bqInput']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqTextarea, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqTextarea, selector: "bq-textarea", inputs: { autoGrow: "autoGrow", autocapitalize: "autocapitalize", autocomplete: "autocomplete", autocorrect: "autocorrect", autofocus: "autofocus", debounceTime: "debounceTime", disableResize: "disableResize", disabled: "disabled", form: "form", formValidationMessage: "formValidationMessage", 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({
+        inputs: ['autoGrow', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'debounceTime', 'disableResize', 'disabled', 'form', 'formValidationMessage', '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: "18.2.13", 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', 'formValidationMessage', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'rows', 'spellcheck', 'validationStatus', 'value', 'wrap'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqToast = class BqToast {
+    /**
+   * The corder radius of the toast component
+   */
+    set border(_) { }
+    ;
+    /**
+   * Type of toast
+   */
+    set type(_) { }
+    ;
+    /**
+   * Placement of toast
+   */
+    set placement(_) { }
+    ;
+    /**
+   * If true will hide toast icon
+   */
+    set hideIcon(_) { }
+    ;
+    /**
+   * If true, the toast will be shown
+   */
+    set open(_) { }
+    ;
+    /**
+   * The length of time, in milliseconds, after which the toast will close itself
+   */
+    set time(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['bqHide', 'bqShow']);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqToast, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqToast, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
+let BqTooltip = class BqTooltip {
+    /**
+   * If true, the tooltip will always be visible
+   */
+    set alwaysVisible(_) { }
+    ;
+    /**
+   * Distance between trigger element and tooltip
+   */
+    set distance(_) { }
+    ;
+    /**
+   * If true, the arrow on the tooltip content won't be shown
+   */
+    set hideArrow(_) { }
+    ;
+    set placement(_) { }
+    ;
+    /**
+   * Whether the tooltip should have the same width as the trigger element
+(applicable only for content shorter than the trigger element)
+   */
+    set sameWidth(_) { }
+    ;
+    /**
+   * Set the action when the tooltip should be displayed, on hover (default) or click
+   */
+    set displayOn(_) { }
+    ;
+    /**
+   * Indicates whether or not the tooltip is visible when the component is first rendered,
+and when interacting with the trigger
+   */
+    set visible(_) { }
+    ;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BqTooltip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BqTooltip, 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({
+        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: "18.2.13", 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'],
+                }]
+        }], 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/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 { Components } from '@beeq/core';\n\n\n@ProxyCmp({\n  inputs: ['appearance', 'disabled', 'expanded', 'noAnimation', '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', 'noAnimation', 'rotate', 'size'],\n})\nexport class BqAccordion {\n  protected el: HTMLBqAccordionElement;\n    /**\n   * The appearance style of the Accordion\n   */\n  set appearance(_: Components.BqAccordion['appearance']) {};\n    /**\n   * If true, the Accordion is disabled\n   */\n  set disabled(_: Components.BqAccordion['disabled']) {};\n    /**\n   * If true, the Accordion is expanded\n   */\n  set expanded(_: Components.BqAccordion['expanded']) {};\n    /**\n   * Animation is set through JS when the browser does not support CSS calc-size()\nIf true, the Accordion animation, will be disabled. No animation will be applied.\n   */\n  set noAnimation(_: Components.BqAccordion['noAnimation']) {};\n    /**\n   * If true, the Accordion expand icon is rotate 180deg when expanded\n   */\n  set rotate(_: Components.BqAccordion['rotate']) {};\n    /**\n   * The size of the Accordion\n   */\n  set size(_: Components.BqAccordion['size']) {};\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', 'bqClick']);\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   * Handler to be called when the accordion is clicked\n   */\n  bqClick: EventEmitter<CustomEvent<HTMLBqAccordionElement>>;\n}\n\n\n@ProxyCmp({\n  inputs: ['appearance', 'expandAll', 'multiple', 'noAnimation', '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', 'noAnimation', 'size'],\n})\nexport class BqAccordionGroup {\n  protected el: HTMLBqAccordionGroupElement;\n    /**\n   * The appearance style of accordion to be applied to all accordions\n   */\n  set appearance(_: Components.BqAccordionGroup['appearance']) {};\n    /**\n   * If true all accordions are expanded\n   */\n  set expandAll(_: Components.BqAccordionGroup['expandAll']) {};\n    /**\n   * Animation is set through JS when the browser does not support CSS calc-size()\nIf true, the accordion animation, will be disabled. No animation will be applied.\n   */\n  set noAnimation(_: Components.BqAccordionGroup['noAnimation']) {};\n    /**\n   * If true multiple accordions can be expanded at the same time\n   */\n  set multiple(_: Components.BqAccordionGroup['multiple']) {};\n    /**\n   * The size of accordion to be applied to all accordions\n   */\n  set size(_: Components.BqAccordionGroup['size']) {};\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  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})\nexport class BqAlert {\n  protected el: HTMLBqAlertElement;\n    /**\n   * If true, the alert will automatically hide after the specified amount of time\n   */\n  set autoDismiss(_: Components.BqAlert['autoDismiss']) {};\n    /**\n   * The corner radius of the alert component\n   */\n  set border(_: Components.BqAlert['border']) {};\n    /**\n   * If true, the close button at the top right of the alert won't be shown\n   */\n  set disableClose(_: Components.BqAlert['disableClose']) {};\n    /**\n   * If true, the alert icon won't be shown\n   */\n  set hideIcon(_: Components.BqAlert['hideIcon']) {};\n    /**\n   * If true, the alert will be shown\n   */\n  set open(_: Components.BqAlert['open']) {};\n    /**\n   * The length of time, in milliseconds, after which the alert will close itself. Only valid if `autoDismiss=\"true\"`\n   */\n  set time(_: Components.BqAlert['time']) {};\n    /**\n   * Type of Alert\n   */\n  set type(_: Components.BqAlert['type']) {};\n    /**\n   * If true, the alert component will remain fixed at the top of the page, occupying the full viewport\n   */\n  set sticky(_: Components.BqAlert['sticky']) {};\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n    proxyOutputs(this, this.el, ['bqHide', 'bqShow', 'bqAfterShow', 'bqAfterHide']);\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 shown\n   */\n  bqAfterShow: EventEmitter<CustomEvent<any>>;\n  /**\n   * Callback handler to be called after the alert has been hidden\n   */\n  bqAfterHide: EventEmitter<CustomEvent<any>>;\n}\n\n\n@ProxyCmp({\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})\nexport class BqAvatar {\n  protected el: HTMLBqAvatarElement;\n    /**\n   * Alternate text for the avatar image if the image cannot be displayed\n   */\n  set altText(_: Components.BqAvatar['altText']) {};\n    /**\n   * The image source to load on the avatar (this can be also a base64 encoded image)\n   */\n  set image(_: Components.BqAvatar['image']) {};\n    /**\n   * A text to use for describing the avatar on assistive devices\n   */\n  set label(_: Components.BqAvatar['label']) {};\n    /**\n   * The text to display on avatar\n   */\n  set initials(_: Components.BqAvatar['initials']) {};\n    /**\n   * The shape of the avatar\n   */\n  set shape(_: Components.BqAvatar['shape']) {};\n    /**\n   * The size of the avatar\n   */\n  set size(_: Components.BqAvatar['size']) {};\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  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})\nexport class BqBadge {\n  protected el: HTMLBqBadgeElement;\n    /**\n   * Badge background color. The value should be a valid value of the palette color\n   */\n  set backgroundColor(_: Components.BqBadge['backgroundColor']) {};\n    /**\n   * Badge number color. The value should be a valid value of the palette color\n   */\n  set textColor(_: Components.BqBadge['textColor']) {};\n    /**\n   * The size of the badge. Relevant if badge has no content.\n   */\n  set size(_: Components.BqBadge['size']) {};\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  inputs: ['label']\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: ['label'],\n})\nexport class BqBreadcrumb {\n  protected el: HTMLBqBreadcrumbElement;\n    /**\n   * The `aria-label` attribute to describe the type of navigation\n   */\n  set label(_: Components.BqBreadcrumb['label']) {};\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqBreadcrumb extends Components.BqBreadcrumb {}\n\n\n@ProxyCmp({\n  inputs: ['href', '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: ['href', 'rel', 'target'],\n})\nexport class BqBreadcrumbItem {\n  protected el: HTMLBqBreadcrumbItemElement;\n    /**\n   * If set, the breadcrumb item will be rendered as an `<a>` with this `href`, otherwise, a `<button>` will be rendered.\n   */\n  set href(_: Components.BqBreadcrumbItem['href']) {};\n    /**\n   * Where to display the link in the browser context. Relevant only if `href` is set.\n   */\n  set target(_: Components.BqBreadcrumbItem['target']) {};\n    /**\n   * Where to display the link in the browser context. Relevant only if `href` is set.\n   */\n  set rel(_: Components.BqBreadcrumbItem['rel']) {};\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  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})\nexport class BqButton {\n  protected el: HTMLBqButtonElement;\n    /**\n   * The appearance style to apply to the button\n   */\n  set appearance(_: Components.BqButton['appearance']) {};\n    /**\n   * If `true`, it will make the button fit to its parent width.\n   */\n  set block(_: Components.BqButton['block']) {};\n    /**\n   * The corner radius of the button\n   */\n  set border(_: Components.BqButton['border']) {};\n    /**\n   * If true, the button will be disabled (no interaction allowed)\n   */\n  set disabled(_: Components.BqButton['disabled']) {};\n    /**\n   * Tells the browser to treat the linked URL as a download. Only used when `href` is set.\nDetails: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-download\n   */\n  set download(_: Components.BqButton['download']) {};\n    /**\n   * When set, the underlying button will be rendered as an `<a>` with this `href` instead of a `<button>`\n   */\n  set href(_: Components.BqButton['href']) {};\n    /**\n   * It determinate how the content should be aligned\n   */\n  set justifyContent(_: Components.BqButton['justifyContent']) {};\n    /**\n   * If `true` it will display the button in a loading state\n   */\n  set loading(_: Components.BqButton['loading']) {};\n    /**\n   * The size of the button\n   */\n  set size(_: Components.BqButton['size']) {};\n    /**\n   * Where to display the linked URL, as the name for a browsing context (a `tab`, `window`, or `<iframe>`)\nDetails: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-target\n   */\n  set target(_: Components.BqButton['target']) {};\n    /**\n   * The default behavior of the button\n   */\n  set type(_: Components.BqButton['type']) {};\n    /**\n   * The variant of button to apply on top of the appearance (applicable only to `appearance=\"primary\"`)\n   */\n  set variant(_: Components.BqButton['variant']) {};\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  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})\nexport class BqCard {\n  protected el: HTMLBqCardElement;\n    /**\n   * Type of card component\n   */\n  set type(_: Components.BqCard['type']) {};\n    /**\n   * The corner radius of the card component\n   */\n  set border(_: Components.BqCard['border']) {};\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  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'formValidationMessage', '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', 'formValidationMessage', 'indeterminate', 'name', 'required', 'value'],\n})\nexport class BqCheckbox {\n  protected el: HTMLBqCheckboxElement;\n    /**\n   * If true checkbox displays background on hover\n   */\n  set backgroundOnHover(_: Components.BqCheckbox['backgroundOnHover']) {};\n    /**\n   * The form ID that the checkbox is associated with\n   */\n  set formId(_: Components.BqCheckbox['formId']) {};\n    /**\n   * The native form validation message\n   */\n  set formValidationMessage(_: Components.BqCheckbox['formValidationMessage']) {};\n    /**\n   * If true checkbox is checked\n   */\n  set checked(_: Components.BqCheckbox['checked']) {};\n    /**\n   * If true checkbox is disabled\n   */\n  set disabled(_: Components.BqCheckbox['disabled']) {};\n    /**\n   * A state that is neither checked nor unchecked\n   */\n  set indeterminate(_: Components.BqCheckbox['indeterminate']) {};\n    /**\n   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.\n   */\n  set name(_: Components.BqCheckbox['name']) {};\n    /**\n   * If `true`, it will indicate that the user must specify a value for the checkbox before the owning form can be submitted\n   */\n  set required(_: Components.BqCheckbox['required']) {};\n    /**\n   * A string representing the value of the checkbox. Primarily used to differentiate a list of related checkboxes that have the same name.\n   */\n  set value(_: Components.BqCheckbox['value']) {};\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 checkbox 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  inputs: ['autofocus', 'clearButtonLabel', 'disableClear', 'disabled', 'distance', 'firstDayOfWeek', 'form', 'formValidationMessage', 'formatOptions', 'isDateDisallowed', 'locale', 'max', 'min', 'months', 'monthsPerView', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'required', 'showOutsideDays', 'skidding', 'strategy', 'tentative', 'type', 'validationStatus', 'value'],\n  methods: ['clear']\n})\n@Component({\n  selector: 'bq-date-picker',\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', 'firstDayOfWeek', 'form', 'formValidationMessage', 'formatOptions', 'isDateDisallowed', 'locale', 'max', 'min', 'months', 'monthsPerView', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'required', 'showOutsideDays', 'skidding', 'strategy', 'tentative', 'type', 'validationStatus', 'value'],\n})\nexport class BqDatePicker {\n  protected el: HTMLBqDatePickerElement;\n    /**\n   * If `true`, the Date picker input will be focused on component render\n   */\n  set autofocus(_: Components.BqDatePicker['autofocus']) {};\n    /**\n   * The clear button aria label\n   */\n  set clearButtonLabel(_: Components.BqDatePicker['clearButtonLabel']) {};\n    /**\n   * If `true`, the clear button won't be displayed\n   */\n  set disableClear(_: Components.BqDatePicker['disableClear']) {};\n    /**\n   * Indicates whether the Date picker input is disabled or not.\nIf `true`, the Date picker is disabled and cannot be interacted with.\n   */\n  set disabled(_: Components.BqDatePicker['disabled']) {};\n    /**\n   * Represents the distance (gutter or margin) between the Date picker panel and the input element.\n   */\n  set distance(_: Components.BqDatePicker['distance']) {};\n    /**\n   * The first day of the week, where Sunday is 0, Monday is 1, etc\n   */\n  set firstDayOfWeek(_: Components.BqDatePicker['firstDayOfWeek']) {};\n    /**\n   * The options to use when formatting the displayed value.\nDetails: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat#using_options\n   */\n  set formatOptions(_: Components.BqDatePicker['formatOptions']) {};\n    /**\n   * The ID of the form that the Date picker input belongs to.\n   */\n  set form(_: Components.BqDatePicker['form']) {};\n    /**\n   * The native form validation message (mandatory if `required` is set)\n   */\n  set formValidationMessage(_: Components.BqDatePicker['formValidationMessage']) {};\n    /**\n   * A function that takes a date and returns true if the date should not be selectable\n   */\n  set isDateDisallowed(_: Components.BqDatePicker['isDateDisallowed']) {};\n    /**\n   * The locale for formatting dates. If not set, will use the browser's locale.\nDetails: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument\n   */\n  set locale(_: Components.BqDatePicker['locale']) {};\n    /**\n   * The latest date that can be selected\n   */\n  set max(_: Components.BqDatePicker['max']) {};\n    /**\n   * The earliest date that can be selected\n   */\n  set min(_: Components.BqDatePicker['min']) {};\n    /**\n   * Number of months to show when range is `true`\n   */\n  set months(_: Components.BqDatePicker['months']) {};\n    /**\n   * Specifies how the next/previous buttons should navigate the calendar.\n- single: The buttons will navigate by a single month at a time.\n- months: The buttons will navigate by the number of months displayed per view.\n   */\n  set monthsPerView(_: Components.BqDatePicker['monthsPerView']) {};\n    /**\n   * The Date picker input name.\n   */\n  set name(_: Components.BqDatePicker['name']) {};\n    /**\n   * If `true`, the Date picker panel will be visible.\n   */\n  set open(_: Components.BqDatePicker['open']) {};\n    /**\n   * When set, it will override the height of the Date picker panel.\n   */\n  set panelHeight(_: Components.BqDatePicker['panelHeight']) {};\n    /**\n   * The Date picker input placeholder text value\n   */\n  set placeholder(_: Components.BqDatePicker['placeholder']) {};\n    /**\n   * Position of the Date picker panel\n   */\n  set placement(_: Components.BqDatePicker['placement']) {};\n    /**\n   * Indicates whether or not the Date picker input is required to be filled out before submitting the form.\n   */\n  set required(_: Components.BqDatePicker['required']) {};\n    /**\n   * Represents the skidding between the Date picker panel and the input element.\n   */\n  set skidding(_: Components.BqDatePicker['skidding']) {};\n    /**\n   * Whether to show days outside the month\n   */\n  set showOutsideDays(_: Components.BqDatePicker['showOutsideDays']) {};\n    /**\n   * Defines the strategy to position the Date picker panel\n   */\n  set strategy(_: Components.BqDatePicker['strategy']) {};\n    /**\n   * The date that is tentatively selected e.g. the start of a range selection\n   */\n  set tentative(_: Components.BqDatePicker['tentative']) {};\n    /**\n   * It defines how the calendar will behave, allowing single date selection, range selection, or multiple date selection\n   */\n  set type(_: Components.BqDatePicker['type']) {};\n    /**\n   * The validation status of the Select input. @remarks This property is used to indicate the validation status of the select input. It can be set to one of the following values:\n- `'none'`: No validation status is set.\n- `'error'`: The input has a validation error.\n- `'warning'`: The input has a validation warning.\n- `'success'`: The input has passed validation.\n   */\n  set validationStatus(_: Components.BqDatePicker['validationStatus']) {};\n    /**\n   * The select input value represents the currently selected date or range and can be used to reset the field to a previous value.\nAll dates are expected in ISO-8601 format (YYYY-MM-DD).\n   */\n  set value(_: Components.BqDatePicker['value']) {};\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']);\n  }\n}\n\n\nexport declare interface BqDatePicker extends Components.BqDatePicker {\n  /**\n   * Callback handler emitted when the input loses focus\n   */\n  bqBlur: EventEmitter<CustomEvent<HTMLBqDatePickerElement>>;\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; el: HTMLBqDatePickerElement }>>;\n  /**\n   * Callback handler emitted when the input value has been cleared\n   */\n  bqClear: EventEmitter<CustomEvent<HTMLBqDatePickerElement>>;\n  /**\n   * Callback handler emitted when the input has received focus\n   */\n  bqFocus: EventEmitter<CustomEvent<HTMLBqDatePickerElement>>;\n}\n\n\n@ProxyCmp({\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})\nexport class BqDialog {\n  protected el: HTMLBqDialogElement;\n    /**\n   * Border radius of the dialog component\n   */\n  set border(_: Components.BqDialog['border']) {};\n    /**\n   * If true, the backdrop overlay won't be shown when the dialog opens\n   */\n  set disableBackdrop(_: Components.BqDialog['disableBackdrop']) {};\n    /**\n   * If true, the dialog will not close when the [Esc] key is press\n   */\n  set disableCloseEscKeydown(_: Components.BqDialog['disableCloseEscKeydown']) {};\n    /**\n   * If true, the dialog will not close when clicking on the backdrop overlay\n   */\n  set disableCloseClickOutside(_: Components.BqDialog['disableCloseClickOutside']) {};\n    /**\n   * The appearance of footer\n   */\n  set footerAppearance(_: Components.BqDialog['footerAppearance']) {};\n    /**\n   * If true, it hides the close button\n   */\n  set hideCloseButton(_: Components.BqDialog['hideCloseButton']) {};\n    /**\n   * If true, the dialog will be shown as open\n   */\n  set open(_: Components.BqDialog['open']) {};\n    /**\n   * The size of the dialog\n   */\n  set size(_: Components.BqDialog['size']) {};\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  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})\nexport class BqDivider {\n  protected el: HTMLBqDividerElement;\n    /**\n   * If true, the divider has a dashed pattern\n   */\n  set dashed(_: Components.BqDivider['dashed']) {};\n    /**\n   * The default orientation of the divider\n   */\n  set orientation(_: Components.BqDivider['orientation']) {};\n    /**\n   * Set the stroke color of the divider. The value should be a valid value of the palette color\n   */\n  set strokeColor(_: Components.BqDivider['strokeColor']) {};\n    /**\n   * Set the alignment of the title on the main axis of the divider (horizontal / vertical)\n   */\n  set titleAlignment(_: Components.BqDivider['titleAlignment']) {};\n    /**\n   * Set the width of each dash of the divider's stroke. This is applicable when the stroke is dashed\n   */\n  set strokeDashWidth(_: Components.BqDivider['strokeDashWidth']) {};\n    /**\n   * Set the gap of the divider's stroke. This is applicable when the stroke is dashed\n   */\n  set strokeDashGap(_: Components.BqDivider['strokeDashGap']) {};\n    /**\n   * Set the thickness of the divider's stroke. Value expressed in px\n   */\n  set strokeThickness(_: Components.BqDivider['strokeThickness']) {};\n    /**\n   * Set the min width of the divider's stroke when text is not centered. Value expressed in px\n   */\n  set strokeBasis(_: Components.BqDivider['strokeBasis']) {};\n    /**\n   * Set the line of the divider's stroke. This is applicable when the stroke is dashed\n   */\n  set strokeLinecap(_: Components.BqDivider['strokeLinecap']) {};\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  inputs: ['closeOnClickOutside', 'closeOnEsc', 'enableBackdrop', 'open', 'placement', 'position'],\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', 'position'],\n})\nexport class BqDrawer {\n  protected el: HTMLBqDrawerElement;\n    /**\n   * If true, the backdrop overlay will be shown when the drawer opens\n   */\n  set enableBackdrop(_: Components.BqDrawer['enableBackdrop']) {};\n    /**\n   * If true, the drawer will not close when clicking outside the panel\n   */\n  set closeOnClickOutside(_: Components.BqDrawer['closeOnClickOutside']) {};\n    /**\n   * If true, the dialog will not close when the [Esc] key is pressed\n   */\n  set closeOnEsc(_: Components.BqDrawer['closeOnEsc']) {};\n    /**\n   * If true, the drawer component will be shown\n   */\n  set open(_: Components.BqDrawer['open']) {};\n    /**\n   *  @deprecated Defines the position of the drawer\n   */\n  set placement(_: Components.BqDrawer['placement']) {};\n    /**\n   * Defines the position of the drawer\n   */\n  set position(_: Components.BqDrawer['position']) {};\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  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})\nexport class BqDropdown {\n  protected el: HTMLBqDropdownElement;\n    /**\n   * If true, the dropdown panel will be visible and won't be shown.\n   */\n  set disabled(_: Components.BqDropdown['disabled']) {};\n    /**\n   * Represents the distance (gutter or margin) between the panel and the trigger element.\n   */\n  set distance(_: Components.BqDropdown['distance']) {};\n    /**\n   * If true, the panel will remain open after a selection is made.\n   */\n  set keepOpenOnSelect(_: Components.BqDropdown['keepOpenOnSelect']) {};\n    /**\n   * Position of the panel\n   */\n  set placement(_: Components.BqDropdown['placement']) {};\n    /**\n   * If true, the panel will be visible.\n   */\n  set open(_: Components.BqDropdown['open']) {};\n    /**\n   * When set, it will override the height of the dropdown panel\n   */\n  set panelHeight(_: Components.BqDropdown['panelHeight']) {};\n    /**\n   * Whether the panel should have the same width as the trigger element\n   */\n  set sameWidth(_: Components.BqDropdown['sameWidth']) {};\n    /**\n   * Represents the skidding between the panel and the trigger element.\n   */\n  set skidding(_: Components.BqDropdown['skidding']) {};\n    /**\n   * Defines the strategy to position the panel\n   */\n  set strategy(_: Components.BqDropdown['strategy']) {};\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  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})\nexport class BqEmptyState {\n  protected el: HTMLBqEmptyStateElement;\n    /**\n   * The size of the empty state component\n   */\n  set size(_: Components.BqEmptyState['size']) {};\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  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})\nexport class BqIcon {\n  protected el: HTMLBqIconElement;\n    /**\n   * Label for the icon, used for accessibility\n   */\n  set label(_: Components.BqIcon['label']) {};\n    /**\n   * Set the stroke color of the SVG. The value should be a valid value of the palette color\n   */\n  set color(_: Components.BqIcon['color']) {};\n    /**\n   * Icon name to load. Please check all available icons [here](https://phosphoricons.com/)\n   */\n  set name(_: Components.BqIcon['name']) {};\n    /**\n   * Set the size of the SVG\n   */\n  set size(_: Components.BqIcon['size']) {};\n    /**\n   * Set the source of the SVG. If the source is set, the name property will be ignored\n   */\n  set src(_: Components.BqIcon['src']) {};\n    /**\n   *  @deprecated It set the icon weight/style\n   */\n  set weight(_: Components.BqIcon['weight']) {};\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  inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'form', 'formValidationMessage', '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', 'formValidationMessage', 'inputmode', 'max', 'maxlength', 'min', 'minlength', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'step', 'type', 'validationStatus', 'value'],\n})\nexport class BqInput {\n  protected el: HTMLBqInputElement;\n    /**\n   * Controls whether or not the input field should be capitalized and how.\nPossible values are 'off', 'none', 'on', 'sentences', 'words', and 'characters'.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize\n   */\n  set autocapitalize(_: Components.BqInput['autocapitalize']) {};\n    /**\n   * Specifies whether or not the input field should have autocomplete enabled.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values\n   */\n  set autocomplete(_: Components.BqInput['autocomplete']) {};\n    /**\n   * Controls whether or not the input field should have autocorrect enabled.\nPossible values are 'on' and 'off'.\n   */\n  set autocorrect(_: Components.BqInput['autocorrect']) {};\n    /**\n   * If true, the input will be focused on component render\n   */\n  set autofocus(_: Components.BqInput['autofocus']) {};\n    /**\n   * The clear button aria label\n   */\n  set clearButtonLabel(_: Components.BqInput['clearButtonLabel']) {};\n    /**\n   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the input value changes.\nA value of 0 means no debouncing will occur.\n   */\n  set debounceTime(_: Components.BqInput['debounceTime']) {};\n    /**\n   * Indicates whether the input is disabled or not.\nIf `true`, the input is disabled and cannot be interacted with.\n   */\n  set disabled(_: Components.BqInput['disabled']) {};\n    /**\n   * If true, the clear button won't be displayed\n   */\n  set disableClear(_: Components.BqInput['disableClear']) {};\n    /**\n   * The ID of the form that the input field belongs to.\n   */\n  set form(_: Components.BqInput['form']) {};\n    /**\n   * The native form validation message (mandatory if `required` is set)\n   */\n  set formValidationMessage(_: Components.BqInput['formValidationMessage']) {};\n    /**\n   * The inputmode attribute specifies what kind of input mechanism would be most helpful for users entering content into the input field.\nThis allows a browser to display an appropriate virtual keyboard while editing.\nPossible values are 'none', 'text', 'decimal', 'numeric', 'tel', 'search', 'email', 'url', and 'date'.\n   */\n  set inputmode(_: Components.BqInput['inputmode']) {};\n    /**\n   * The maximum value that the input field can accept.\nOnly applies to date and number input types.\n   */\n  set max(_: Components.BqInput['max']) {};\n    /**\n   * The maximum number of characters that the input field can accept.\n   */\n  set maxlength(_: Components.BqInput['maxlength']) {};\n    /**\n   * The minimum value that the input field can accept.\nOnly applies to date and number input types.\n   */\n  set min(_: Components.BqInput['min']) {};\n    /**\n   * The minimum number of characters that the input field can accept.\n   */\n  set minlength(_: Components.BqInput['minlength']) {};\n    /**\n   * The input field name.\n   */\n  set name(_: Components.BqInput['name']) {};\n    /**\n   * Specifies a regular expression the form control's value should match.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/pattern\n   */\n  set pattern(_: Components.BqInput['pattern']) {};\n    /**\n   * The input placeholder text value\n   */\n  set placeholder(_: Components.BqInput['placeholder']) {};\n    /**\n   * If true, the input field cannot be modified.\n   */\n  set readonly(_: Components.BqInput['readonly']) {};\n    /**\n   * Indicates whether or not the input field is required to be filled out before submitting the form.\n   */\n  set required(_: Components.BqInput['required']) {};\n    /**\n   * A number that specifies the granularity that the value must adhere to.\nValid for date, month, week, time, datetime-local, number, and range.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#step\n   */\n  set step(_: Components.BqInput['step']) {};\n    /**\n   * The type attribute specifies the type of input field to display.\nPossible values are 'text', 'password', 'email', 'number', 'tel', 'search', 'url', and more.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#input_types\n   */\n  set type(_: Components.BqInput['type']) {};\n    /**\n   * The validation status of the input. @remarks This property is used to indicate the validation status of the input. It can be set to one of the following values:\n- `'none'`: No validation status is set.\n- `'error'`: The input has a validation error.\n- `'warning'`: The input has a validation warning.\n- `'success'`: The input has passed validation.\n   */\n  set validationStatus(_: Components.BqInput['validationStatus']) {};\n    /**\n   * The input value, it can be used to reset the input to a previous value\n   */\n  set value(_: Components.BqInput['value']) {};\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  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})\nexport class BqNotification {\n  protected el: HTMLBqNotificationElement;\n    /**\n   * If true, the notification will automatically hide after the specified amount of time\n   */\n  set autoDismiss(_: Components.BqNotification['autoDismiss']) {};\n    /**\n   * The corder radius of the notification component\n   */\n  set border(_: Components.BqNotification['border']) {};\n    /**\n   * If true, the close button at the top right of the notification won't be shown\n   */\n  set disableClose(_: Components.BqNotification['disableClose']) {};\n    /**\n   * If true, the notification icon won't be shown\n   */\n  set hideIcon(_: Components.BqNotification['hideIcon']) {};\n    /**\n   * If true, the notification will be shown\n   */\n  set open(_: Components.BqNotification['open']) {};\n    /**\n   * The length of time, in milliseconds, after which the notification will close itself. Only valid if `autoDismiss=\"true\"`\n   */\n  set time(_: Components.BqNotification['time']) {};\n    /**\n   * Type of Notification\n   */\n  set type(_: Components.BqNotification['type']) {};\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  inputs: ['disabled', 'hidden', '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', 'hidden', 'selected', 'value'],\n})\nexport class BqOption {\n  protected el: HTMLBqOptionElement;\n    /**\n   * If true, the option is hidden.\n   */\n  set hidden(_: Components.BqOption['hidden']) {};\n    /**\n   * If true, the option is disabled.\n   */\n  set disabled(_: Components.BqOption['disabled']) {};\n    /**\n   * A string representing the value of the option. Can be used to identify the item\n   */\n  set value(_: Components.BqOption['value']) {};\n    /**\n   * If true, the option is selected and active.\n   */\n  set selected(_: Components.BqOption['selected']) {};\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})\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})\nexport class BqOptionGroup {\n  protected el: HTMLBqOptionGroupElement;\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  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})\nexport class BqOptionList {\n  protected el: HTMLBqOptionListElement;\n    /**\n   * Aria label for the list.\n   */\n  set ariaLabel(_: Components.BqOptionList['ariaLabel']) {};\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})\n@Component({\n  selector: 'bq-page-title',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: '<ng-content></ng-content>',\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: [],\n})\nexport class BqPageTitle {\n  protected el: HTMLBqPageTitleElement;\n  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {\n    c.detach();\n    this.el = r.nativeElement;\n  }\n}\n\n\nexport declare interface BqPageTitle extends Components.BqPageTitle {}\n\n\n@ProxyCmp({\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})\nexport class BqPanel {\n  protected el: HTMLBqPanelElement;\n    /**\n   * Represents the distance (gutter or margin) between the panel and the trigger element.\n   */\n  set distance(_: Components.BqPanel['distance']) {};\n    /**\n   * Position of the panel\n   */\n  set placement(_: Components.BqPanel['placement']) {};\n    /**\n   * If true, the panel will be visible.\n   */\n  set open(_: Components.BqPanel['open']) {};\n    /**\n   * Whether the panel should have the same width as the trigger element\n   */\n  set sameWidth(_: Components.BqPanel['sameWidth']) {};\n    /**\n   * Represents the skidding between the panel and the trigger element.\n   */\n  set skidding(_: Components.BqPanel['skidding']) {};\n    /**\n   * Defines the strategy to position the panel\n   */\n  set strategy(_: Components.BqPanel['strategy']) {};\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  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})\nexport class BqProgress {\n  protected el: HTMLBqProgressElement;\n    /**\n   * It will set the border style of the progress bar\n   */\n  set borderShape(_: Components.BqProgress['borderShape']) {};\n    /**\n   * If `true`, a tooltip will be shown displaying the progress value\n   */\n  set enableTooltip(_: Components.BqProgress['enableTooltip']) {};\n    /**\n   * If `true` the indeterminate state of progress bar is enabled\n   */\n  set indeterminate(_: Components.BqProgress['indeterminate']) {};\n    /**\n   * If `true, a label text showing the value (in percentage) will be shown\n   */\n  set label(_: Components.BqProgress['label']) {};\n    /**\n   * Progress bar thickness\n   */\n  set thickness(_: Components.BqProgress['thickness']) {};\n    /**\n   * Progress type\n   */\n  set type(_: Components.BqProgress['type']) {};\n    /**\n   * A number representing the current value of the progress bar\n   */\n  set value(_: Components.BqProgress['value']) {};\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  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formId', 'name', 'required', 'value'],\n  methods: ['vClick', 'vFocus', 'vBlur', 'getNativeInput']\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})\nexport class BqRadio {\n  protected el: HTMLBqRadioElement;\n    /**\n   * If true radio input is checked\n   */\n  set checked(_: Components.BqRadio['checked']) {};\n    /**\n   * If true radio input is disabled\n   */\n  set disabled(_: Components.BqRadio['disabled']) {};\n    /**\n   * If true radio displays background on hover\n   */\n  set backgroundOnHover(_: Components.BqRadio['backgroundOnHover']) {};\n    /**\n   * The form ID that the radio input is associated with\n   */\n  set formId(_: Components.BqRadio['formId']) {};\n    /**\n   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.\n   */\n  set name(_: Components.BqRadio['name']) {};\n    /**\n   * If `true`, it will indicate that the user must specify a value for the radio before the owning form can be submitted\n   */\n  set required(_: Components.BqRadio['required']) {};\n    /**\n   * A string representing the value of the radio.\n   */\n  set value(_: Components.BqRadio['value']) {};\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  inputs: ['backgroundOnHover', 'debounceTime', 'disabled', 'fieldset', 'name', 'orientation', 'required', 'requiredValidationMessage', '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', 'required', 'requiredValidationMessage', 'value'],\n})\nexport class BqRadioGroup {\n  protected el: HTMLBqRadioGroupElement;\n    /**\n   * If true, all radio inputs in the group will display a background on hover\n   */\n  set backgroundOnHover(_: Components.BqRadioGroup['backgroundOnHover']) {};\n    /**\n   * A number representing the delay time (in milliseconds) that `bqChange` event handler gets triggered once the value change\n   */\n  set debounceTime(_: Components.BqRadioGroup['debounceTime']) {};\n    /**\n   * If true radio inputs are disabled\n   */\n  set disabled(_: Components.BqRadioGroup['disabled']) {};\n    /**\n   * If true displays fieldset\n   */\n  set fieldset(_: Components.BqRadioGroup['fieldset']) {};\n    /**\n   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.\n   */\n  set name(_: Components.BqRadioGroup['name']) {};\n    /**\n   * The display orientation of the radio inputs\n   */\n  set orientation(_: Components.BqRadioGroup['orientation']) {};\n    /**\n   * If true, the radio group is required\n   */\n  set required(_: Components.BqRadioGroup['required']) {};\n    /**\n   * The native form validation message when the radio group is required\n   */\n  set requiredValidationMessage(_: Components.BqRadioGroup['requiredValidationMessage']) {};\n    /**\n   * A string representing the value of the radio.\n   */\n  set value(_: Components.BqRadioGroup['value']) {};\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  inputs: ['autofocus', 'clearButtonLabel', 'debounceTime', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'maxTagsVisible', 'multiple', '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', 'debounceTime', 'disableClear', 'disabled', 'distance', 'form', 'keepOpenOnSelect', 'maxTagsVisible', 'multiple', 'name', 'open', 'panelHeight', 'placeholder', 'placement', 'readonly', 'required', 'sameWidth', 'skidding', 'strategy', 'validationStatus', 'value'],\n})\nexport class BqSelect {\n  protected el: HTMLBqSelectElement;\n    /**\n   * If true, the Select input will be focused on component render\n   */\n  set autofocus(_: Components.BqSelect['autofocus']) {};\n    /**\n   * The clear button aria label\n   */\n  set clearButtonLabel(_: Components.BqSelect['clearButtonLabel']) {};\n    /**\n   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the input value changes.\nA value of 0 means no debouncing will occur.\n   */\n  set debounceTime(_: Components.BqSelect['debounceTime']) {};\n    /**\n   * Indicates whether the Select input is disabled or not.\nIf `true`, the Select is disabled and cannot be interacted with.\n   */\n  set disabled(_: Components.BqSelect['disabled']) {};\n    /**\n   * If true, the clear button won't be displayed\n   */\n  set disableClear(_: Components.BqSelect['disableClear']) {};\n    /**\n   * Represents the distance (gutter or margin) between the Select panel and the input element.\n   */\n  set distance(_: Components.BqSelect['distance']) {};\n    /**\n   * The ID of the form that the Select input belongs to.\n   */\n  set form(_: Components.BqSelect['form']) {};\n    /**\n   * If true, the Select panel will remain open after a selection is made.\n   */\n  set keepOpenOnSelect(_: Components.BqSelect['keepOpenOnSelect']) {};\n    /**\n   * The Select input name.\n   */\n  set name(_: Components.BqSelect['name']) {};\n    /**\n   * The maximum number of tags to display when multiple selection is enabled\n   */\n  set maxTagsVisible(_: Components.BqSelect['maxTagsVisible']) {};\n    /**\n   * If true, the Select input will allow multiple selections.\n   */\n  set multiple(_: Components.BqSelect['multiple']) {};\n    /**\n   * If true, the Select panel will be visible.\n   */\n  set open(_: Components.BqSelect['open']) {};\n    /**\n   * When set, it will override the height of the Select panel.\n   */\n  set panelHeight(_: Components.BqSelect['panelHeight']) {};\n    /**\n   * The Select input placeholder text value\n   */\n  set placeholder(_: Components.BqSelect['placeholder']) {};\n    /**\n   * Position of the Select panel\n   */\n  set placement(_: Components.BqSelect['placement']) {};\n    /**\n   * If true, the list of options cannot be filtered (searching won't be available)\n   */\n  set readonly(_: Components.BqSelect['readonly']) {};\n    /**\n   * Indicates whether or not the Select input is required to be filled out before submitting the form.\n   */\n  set required(_: Components.BqSelect['required']) {};\n    /**\n   * Whether the panel should have the Select same width as the input element\n   */\n  set sameWidth(_: Components.BqSelect['sameWidth']) {};\n    /**\n   * Represents the skidding between the Select panel and the input element.\n   */\n  set skidding(_: Components.BqSelect['skidding']) {};\n    /**\n   * Defines the strategy to position the Select panel\n   */\n  set strategy(_: Components.BqSelect['strategy']) {};\n    /**\n   * The validation status of the Select input. @remarks This property is used to indicate the validation status of the select input. It can be set to one of the following values:\n- `'none'`: No validation status is set.\n- `'error'`: The input has a validation error.\n- `'warning'`: The input has a validation warning.\n- `'success'`: The input has passed validation.\n   */\n  set validationStatus(_: Components.BqSelect['validationStatus']) {};\n    /**\n   * The select input value, it can be used to reset the field to a previous value\n   */\n  set value(_: Components.BqSelect['value']) {};\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  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})\nexport class BqSideMenu {\n  protected el: HTMLBqSideMenuElement;\n    /**\n   * It sets a predefined appearance of the side menu\n   */\n  set appearance(_: Components.BqSideMenu['appearance']) {};\n    /**\n   * If true, the container will reduce its width\n   */\n  set collapse(_: Components.BqSideMenu['collapse']) {};\n    /**\n   * It sets the size of the navigation menu items\n   */\n  set size(_: Components.BqSideMenu['size']) {};\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  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})\nexport class BqSideMenuItem {\n  protected el: HTMLBqSideMenuItemElement;\n    /**\n   * If true, the menu item will be shown as active/selected.\n   */\n  set active(_: Components.BqSideMenuItem['active']) {};\n    /**\n   * If true, the item label and suffix will be hidden and the with will be reduce according to its parent\n   */\n  set collapse(_: Components.BqSideMenuItem['collapse']) {};\n    /**\n   * If true, the menu item will be disabled (no interaction allowed)\n   */\n  set disabled(_: Components.BqSideMenuItem['disabled']) {};\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  inputs: ['debounceTime', 'disabled', 'enableTooltip', 'enableValueIndicator', 'gap', 'max', 'min', 'name', 'step', 'tooltipAlwaysVisible', 'type', 'value']\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', 'enableTooltip', 'enableValueIndicator', 'gap', 'max', 'min', 'name', 'step', 'tooltipAlwaysVisible', 'type', 'value'],\n})\nexport class BqSlider {\n  protected el: HTMLBqSliderElement;\n    /**\n   * The amount of time, in milliseconds, to wait to trigger the `bqChange` event after each value change.\n   */\n  set debounceTime(_: Components.BqSlider['debounceTime']) {};\n    /**\n   * If `true` the slider is disabled.\n   */\n  set disabled(_: Components.BqSlider['disabled']) {};\n    /**\n   * If `true` it will show the value label on a side of the slider track area\n   */\n  set enableValueIndicator(_: Components.BqSlider['enableValueIndicator']) {};\n    /**\n   * A number representing the amount to remain between the minimum and maximum values (only for range type).\n   */\n  set gap(_: Components.BqSlider['gap']) {};\n    /**\n   * A number representing the max value of the slider.\n   */\n  set max(_: Components.BqSlider['max']) {};\n    /**\n   * A number representing the min value of the slider.\n   */\n  set min(_: Components.BqSlider['min']) {};\n    /**\n   * Name of the form control. Submitted with the form as part of a name/value pair\n   */\n  set name(_: Components.BqSlider['name']) {};\n    /**\n   * A number representing the step of the slider.\n⚠️ Please notice that the value (or list of values if the slider type is `range`) will be rounded to the nearest multiple of `step`.\n   */\n  set step(_: Components.BqSlider['step']) {};\n    /**\n   * It defines the type of slider to display\n   */\n  set type(_: Components.BqSlider['type']) {};\n    /**\n   * The value of the slider.\n- If the slider type is `single`, the value is a number.\n- If the slider type is `range`, the value is an array of two numbers (the first number represents the `min` value and the second number represents the `max` value).\n   */\n  set value(_: Components.BqSlider['value']) {};\n    /**\n   * If `true`, a tooltip will be shown displaying the progress value\n   */\n  set enableTooltip(_: Components.BqSlider['enableTooltip']) {};\n    /**\n   * If `true`, a tooltip will always display the progress value.\nIt relies on enableTooltip and if enableTooltip is false, tooltipAlwaysVisible cannot be true.\n   */\n  set tooltipAlwaysVisible(_: Components.BqSlider['tooltipAlwaysVisible']) {};\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\nimport type { TSliderValue as IBqSliderTSliderValue } from '@beeq/core';\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: Exclude<IBqSliderTSliderValue, 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  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})\nexport class BqSpinner {\n  protected el: HTMLBqSpinnerElement;\n    /**\n   * If `false`, the animation on the icon element will be stopped\n   */\n  set animation(_: Components.BqSpinner['animation']) {};\n    /**\n   * It defines the position of the label text\n   */\n  set textPosition(_: Components.BqSpinner['textPosition']) {};\n    /**\n   * It defines the size of the icon element displayed\n   */\n  set size(_: Components.BqSpinner['size']) {};\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  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})\nexport class BqStatus {\n  protected el: HTMLBqStatusElement;\n    /**\n   * It defines the type of status to display\n   */\n  set type(_: Components.BqStatus['type']) {};\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  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})\nexport class BqStepItem {\n  protected el: HTMLBqStepItemElement;\n    /**\n   * It defines prefix size\n   */\n  set size(_: Components.BqStepItem['size']) {};\n    /**\n   * It defines step item appearance based on its status\n   */\n  set status(_: Components.BqStepItem['status']) {};\n    /**\n   * It defines the step item type used\n   */\n  set type(_: Components.BqStepItem['type']) {};\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   * Callback handler emitted when the step item is clicked\n   */\n  bqClick: EventEmitter<CustomEvent<{ target: HTMLBqStepItemElement; value: string }>>;\n}\n\n\n@ProxyCmp({\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})\nexport class BqSteps {\n  protected el: HTMLBqStepsElement;\n    /**\n   * The color of the line that connects the steps. It should be a valid declarative color token.\n   */\n  set dividerColor(_: Components.BqSteps['dividerColor']) {};\n    /**\n   * The size of the steps\n   */\n  set size(_: Components.BqSteps['size']) {};\n    /**\n   * The type of prefix element to use on the step items\n   */\n  set type(_: Components.BqSteps['type']) {};\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  inputs: ['backgroundOnHover', 'checked', 'disabled', 'formValidationMessage', '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', 'formValidationMessage', 'fullWidth', 'innerLabel', 'justifyContent', 'name', 'required', 'reverseOrder', 'value'],\n})\nexport class BqSwitch {\n  protected el: HTMLBqSwitchElement;\n    /**\n   * If true, a background will be displayed on hover\n   */\n  set backgroundOnHover(_: Components.BqSwitch['backgroundOnHover']) {};\n    /**\n   * It indicates whether if the switch is `ON` by default (when the page loads)\n   */\n  set checked(_: Components.BqSwitch['checked']) {};\n    /**\n   * If true, the switch control will be disabled and no interaction will be allowed\n   */\n  set disabled(_: Components.BqSwitch['disabled']) {};\n    /**\n   * The native form validation message\n   */\n  set formValidationMessage(_: Components.BqSwitch['formValidationMessage']) {};\n    /**\n   * If true, the component will take the full width space available on the parent container\n   */\n  set fullWidth(_: Components.BqSwitch['fullWidth']) {};\n    /**\n   * It indicates how to to display the on/off marks inside the control, with icons or none (default)\n   */\n  set innerLabel(_: Components.BqSwitch['innerLabel']) {};\n    /**\n   * It defines how to distribute the space between and around the control and the label text\n(https://developer.mozilla.org/en-US/docs/Web/CSS/justify-content)\n   */\n  set justifyContent(_: Components.BqSwitch['justifyContent']) {};\n    /**\n   * Name of the form control. Submitted with the form as part of a name/value pair\n   */\n  set name(_: Components.BqSwitch['name']) {};\n    /**\n   * If `true`, it will indicate that the user must switch `ON` the element before the owning form can be submitted\n   */\n  set required(_: Components.BqSwitch['required']) {};\n    /**\n   * If true, the order of the control and the label text will be changed\n   */\n  set reverseOrder(_: Components.BqSwitch['reverseOrder']) {};\n    /**\n   * The input control's value, submitted as a name/value pair with form data.\n   */\n  set value(_: Components.BqSwitch['value']) {};\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  inputs: ['active', 'controls', 'disabled', 'orientation', 'placement', 'size', 'tabId'],\n  methods: ['vClick', 'vFocus', 'vBlur']\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', 'orientation', 'placement', 'size', 'tabId'],\n})\nexport class BqTab {\n  protected el: HTMLBqTabElement;\n    /**\n   * If true tab is active\n   */\n  set active(_: Components.BqTab['active']) {};\n    /**\n   * The tab panel id that the tab controls\n   */\n  set controls(_: Components.BqTab['controls']) {};\n    /**\n   * If true tab is disabled\n   */\n  set disabled(_: Components.BqTab['disabled']) {};\n    /**\n   * The direction that tab should be render\n   */\n  set orientation(_: Components.BqTab['orientation']) {};\n    /**\n   * The placement that tab should be render\n   */\n  set placement(_: Components.BqTab['placement']) {};\n    /**\n   * The size of the tab\n   */\n  set size(_: Components.BqTab['size']) {};\n    /**\n   * The id of the tab\n   */\n  set tabId(_: Components.BqTab['tabId']) {};\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  inputs: ['debounceTime', 'disableDivider', 'orientation', 'placement', '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', 'orientation', 'placement', 'size', 'value'],\n})\nexport class BqTabGroup {\n  protected el: HTMLBqTabGroupElement;\n    /**\n   * A number representing the delay value applied to bqChange event handler\n   */\n  set debounceTime(_: Components.BqTabGroup['debounceTime']) {};\n    /**\n   * If true, the underline divider below the tabs won't be shown\n   */\n  set disableDivider(_: Components.BqTabGroup['disableDivider']) {};\n    /**\n   * The direction that tab should be render\n   */\n  set orientation(_: Components.BqTabGroup['orientation']) {};\n    /**\n   * The placement that tab should be render\n   */\n  set placement(_: Components.BqTabGroup['placement']) {};\n    /**\n   * The size of the tab\n   */\n  set size(_: Components.BqTabGroup['size']) {};\n    /**\n   * A string representing the id of the selected tab.\n   */\n  set value(_: Components.BqTabGroup['value']) {};\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  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})\nexport class BqTag {\n  protected el: HTMLBqTagElement;\n    /**\n   * The corner radius of the Tag (will override size's predefined border)\n   */\n  set border(_: Components.BqTag['border']) {};\n    /**\n   * If true, the Tag can be clickable\n   */\n  set clickable(_: Components.BqTag['clickable']) {};\n    /**\n   * The color style of the Tag\n   */\n  set color(_: Components.BqTag['color']) {};\n    /**\n   * If true, the Tag will be disabled (only if clickable = `true`, no interaction allowed)\n   */\n  set disabled(_: Components.BqTag['disabled']) {};\n    /**\n   * If true, the Tag component will hidden (only if removable = `true`)\n   */\n  set hidden(_: Components.BqTag['hidden']) {};\n    /**\n   * If true, the Tag component can be removed\n   */\n  set removable(_: Components.BqTag['removable']) {};\n    /**\n   * If true, the Tag is selected (only if clickable = `true`)\n   */\n  set selected(_: Components.BqTag['selected']) {};\n    /**\n   * The size of the Tag component\n   */\n  set size(_: Components.BqTag['size']) {};\n    /**\n   * The variant of Tag to apply on top of the variant\n   */\n  set variant(_: Components.BqTag['variant']) {};\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  inputs: ['autoGrow', 'autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'debounceTime', 'disableResize', 'disabled', 'form', 'formValidationMessage', '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', 'formValidationMessage', 'maxlength', 'name', 'placeholder', 'readonly', 'required', 'rows', 'spellcheck', 'validationStatus', 'value', 'wrap'],\n})\nexport class BqTextarea {\n  protected el: HTMLBqTextareaElement;\n    /**\n   * Controls whether or not the textarea field should be capitalized and how.\nPossible values are 'off', 'none', 'on', 'sentences', 'words', and 'characters'.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize\n   */\n  set autocapitalize(_: Components.BqTextarea['autocapitalize']) {};\n    /**\n   * Specifies whether or not the textarea field should have autocomplete enabled.\nSee: https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values\n   */\n  set autocomplete(_: Components.BqTextarea['autocomplete']) {};\n    /**\n   * Controls whether or not the textarea field should have autocorrect enabled.\nPossible values are 'on' and 'off'.\n   */\n  set autocorrect(_: Components.BqTextarea['autocorrect']) {};\n    /**\n   * If true, the textarea will be focused on component render\n   */\n  set autofocus(_: Components.BqTextarea['autofocus']) {};\n    /**\n   * If `true`, the textarea will automatically grow and shrink to fit its contents.\nIf `false`, the textarea will have a fixed height specified by the `rows` property.\n   */\n  set autoGrow(_: Components.BqTextarea['autoGrow']) {};\n    /**\n   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the textarea value changes.\nA value of 0 means no debouncing will occur.\n   */\n  set debounceTime(_: Components.BqTextarea['debounceTime']) {};\n    /**\n   * If `true`, the user cannot interact with the textarea.\n   */\n  set disabled(_: Components.BqTextarea['disabled']) {};\n    /**\n   * If `true`, it will block the user's ability to resize the textarea.\n   */\n  set disableResize(_: Components.BqTextarea['disableResize']) {};\n    /**\n   * The ID of the form that the textarea field belongs to.\n   */\n  set form(_: Components.BqTextarea['form']) {};\n    /**\n   * The native form validation message\n   */\n  set formValidationMessage(_: Components.BqTextarea['formValidationMessage']) {};\n    /**\n   * The maximum number of characters that can be entered into the textarea (`0`: no limit).\nWhen enabled, a character counter will be shown underneath the textarea.\n   */\n  set maxlength(_: Components.BqTextarea['maxlength']) {};\n    /**\n   * The name of the textarea element.\n   */\n  set name(_: Components.BqTextarea['name']) {};\n    /**\n   * The placeholder text to show when there is no value.\n   */\n  set placeholder(_: Components.BqTextarea['placeholder']) {};\n    /**\n   * If true, the textarea field cannot be modified.\n   */\n  set readonly(_: Components.BqTextarea['readonly']) {};\n    /**\n   * Indicates whether or not the textarea field is required to be filled out before submitting the form.\n   */\n  set required(_: Components.BqTextarea['required']) {};\n    /**\n   * The number of visible text lines for the control. It must be a positive integer.\n   */\n  set rows(_: Components.BqTextarea['rows']) {};\n    /**\n   * If true, the textarea content may be checked for spelling errors.\n   */\n  set spellcheck(_: Components.BqTextarea['spellcheck']) {};\n    /**\n   * The validation status of the textarea. @remarks This property is used to indicate the validation status of the textarea. It can be set to one of the following values:\n- `'none'`: No validation status is set.\n- `'error'`: The textarea has a validation error.\n- `'warning'`: The textarea has a validation warning.\n- `'success'`: The textarea has passed validation.\n   */\n  set validationStatus(_: Components.BqTextarea['validationStatus']) {};\n    /**\n   * The value of the textarea. It can be used to reset the textarea to a previous value.\n   */\n  set value(_: Components.BqTextarea['value']) {};\n    /**\n   * Specifies how the text in a text area is to be wrapped when submitted in a form\n   */\n  set wrap(_: Components.BqTextarea['wrap']) {};\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  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})\nexport class BqToast {\n  protected el: HTMLBqToastElement;\n    /**\n   * The corder radius of the toast component\n   */\n  set border(_: Components.BqToast['border']) {};\n    /**\n   * Type of toast\n   */\n  set type(_: Components.BqToast['type']) {};\n    /**\n   * Placement of toast\n   */\n  set placement(_: Components.BqToast['placement']) {};\n    /**\n   * If true will hide toast icon\n   */\n  set hideIcon(_: Components.BqToast['hideIcon']) {};\n    /**\n   * If true, the toast will be shown\n   */\n  set open(_: Components.BqToast['open']) {};\n    /**\n   * The length of time, in milliseconds, after which the toast will close itself\n   */\n  set time(_: Components.BqToast['time']) {};\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  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})\nexport class BqTooltip {\n  protected el: HTMLBqTooltipElement;\n    /**\n   * If true, the tooltip will always be visible\n   */\n  set alwaysVisible(_: Components.BqTooltip['alwaysVisible']) {};\n    /**\n   * Distance between trigger element and tooltip\n   */\n  set distance(_: Components.BqTooltip['distance']) {};\n    /**\n   * If true, the arrow on the tooltip content won't be shown\n   */\n  set hideArrow(_: Components.BqTooltip['hideArrow']) {};\n  \n  set placement(_: Components.BqTooltip['placement']) {};\n    /**\n   * Whether the tooltip should have the same width as the trigger element\n(applicable only for content shorter than the trigger element)\n   */\n  set sameWidth(_: Components.BqTooltip['sameWidth']) {};\n    /**\n   * Set the action when the tooltip should be displayed, on hover (default) or click\n   */\n  set displayOn(_: Components.BqTooltip['displayOn']) {};\n    /**\n   * Indicates whether or not the tooltip is visible when the component is first rendered,\nand when interacting with the trigger\n   */\n  set visible(_: Components.BqTooltip['visible']) {};\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"]}