import * as i0 from "@angular/core";
import { ChangeDetectorRef, ElementRef, EventEmitter, ModuleWithProviders, NgZone } from "@angular/core";
import { ControlValueAccessor } from "@angular/forms";
import { BqAccordionCustomEvent, BqAlertCustomEvent, BqBreadcrumbItemCustomEvent, BqButtonCustomEvent, BqCheckboxCustomEvent, BqDatePickerCustomEvent, BqDialogCustomEvent, BqDrawerCustomEvent, BqDropdownCustomEvent, BqIconCustomEvent, BqInputCustomEvent, BqNotificationCustomEvent, BqOptionCustomEvent, BqOptionListCustomEvent, BqRadioCustomEvent, BqRadioGroupCustomEvent, BqSelectCustomEvent, BqSideMenuCustomEvent, BqSideMenuItemCustomEvent, BqSliderCustomEvent, BqStepItemCustomEvent, BqSwitchCustomEvent, BqTabCustomEvent, BqTabGroupCustomEvent, BqTagCustomEvent, BqTextareaCustomEvent, BqTimePickerCustomEvent, BqToastCustomEvent, BqTooltipCustomEvent, Components, TCalendarView, TSelectChangeDetail, TSliderValue } from "@beeq/core";
import * as i7 from "@angular/common";
declare class ValueAccessor implements ControlValueAccessor {
  protected el: ElementRef;
  private onChange;
  private onTouched;
  protected lastValue: any;
  constructor(el: ElementRef);
  writeValue(value: any): void;
  handleChangeEvent(value: any): void;
  _handleBlurEvent(): void;
  registerOnChange(fn: (value: any) => void): void;
  registerOnTouched(fn: () => void): void;
  setDisabledState(isDisabled: boolean): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<ValueAccessor, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<ValueAccessor, never, never, {}, {}, never, never, true, never>;
}
declare namespace boolean_value_accessor_d_exports {
  export { BooleanValueAccessor };
}
export declare class BooleanValueAccessor extends ValueAccessor {
  constructor(el: ElementRef);
  writeValue(value: any): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<BooleanValueAccessor, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<BooleanValueAccessor, "bq-checkbox, bq-switch", never, {}, {}, never, never, false, never>;
}
declare namespace number_value_accessor_d_exports {
  export { NumericValueAccessor };
}
export declare class NumericValueAccessor extends ValueAccessor {
  constructor(el: ElementRef);
  registerOnChange(fn: (_: number | null) => void): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<NumericValueAccessor, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<NumericValueAccessor, "bq-input[type=\"number\"], bq-slider:not[type=\"range\"]", never, {}, {}, never, never, false, never>;
}
declare namespace radio_value_accessor_d_exports {
  export { RadioValueAccessor };
}
export declare class RadioValueAccessor extends ValueAccessor {
  constructor(el: ElementRef);
  static ɵfac: i0.ɵɵFactoryDeclaration<RadioValueAccessor, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<RadioValueAccessor, "bq-radio-group", never, {}, {}, never, never, false, never>;
}
declare namespace select_value_accessor_d_exports {
  export { SelectValueAccessor };
}
export declare class SelectValueAccessor extends ValueAccessor {
  constructor(el: ElementRef);
  static ɵfac: i0.ɵɵFactoryDeclaration<SelectValueAccessor, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<SelectValueAccessor, "bq-select", never, {}, {}, never, never, false, never>;
}
declare namespace text_value_accessor_d_exports {
  export { TextValueAccessor };
}
export declare class TextValueAccessor extends ValueAccessor {
  constructor(el: ElementRef);
  static ɵfac: i0.ɵɵFactoryDeclaration<TextValueAccessor, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<TextValueAccessor, "bq-date-picker, bq-input:not[type=\"number\"], bq-slider[type=\"range\"], bq-textarea, bq-time-picker", never, {}, {}, never, never, false, never>;
}
declare namespace components_d_exports {
  export { BqAccordion, BqAccordionGroup, BqAlert, BqAvatar, BqBadge, BqBreadcrumb, BqBreadcrumbItem, BqButton, BqCard, BqCheckbox, BqDatePicker, BqDialog, BqDivider, BqDrawer, BqDropdown, BqEmptyState, BqIcon, BqInput, BqNotification, BqOption, BqOptionGroup, BqOptionList, BqPageTitle, BqPanel, BqProgress, BqRadio, BqRadioGroup, BqSelect, BqSideMenu, BqSideMenuItem, BqSlider, BqSpinner, BqStatus, BqStepItem, BqSteps, BqSwitch, BqTab, BqTabGroup, BqTag, BqTextarea, BqTimePicker, BqToast, BqTooltip };
}
export declare class BqAccordion {
  protected z: NgZone;
  protected el: HTMLBqAccordionElement;
  /**
   * The appearance style of the Accordion @default 'filled'
   */
  set appearance(_: Components.BqAccordion['appearance']);
  /**
   * If true, the Accordion is disabled @default false
   */
  set disabled(_: Components.BqAccordion['disabled']);
  /**
   * If true, the Accordion is expanded @default false
   */
  set expanded(_: Components.BqAccordion['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. @default false
   */
  set noAnimation(_: Components.BqAccordion['noAnimation']);
  /**
   * If true, the Accordion expand icon is rotate 180deg when expanded @default false
   */
  set rotate(_: Components.BqAccordion['rotate']);
  /**
   * The size of the Accordion @default 'medium'
   */
  set size(_: Components.BqAccordion['size']);
  bqBlur: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  bqFocus: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  bqOpen: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  bqAfterOpen: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  bqClose: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  bqAfterClose: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  bqClick: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqAccordion, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqAccordion, "bq-accordion", never, {
    "appearance": {
      "alias": "appearance";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "expanded": {
      "alias": "expanded";
      "required": false;
    };
    "noAnimation": {
      "alias": "noAnimation";
      "required": false;
    };
    "rotate": {
      "alias": "rotate";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqFocus": "bqFocus";
    "bqOpen": "bqOpen";
    "bqAfterOpen": "bqAfterOpen";
    "bqClose": "bqClose";
    "bqAfterClose": "bqAfterClose";
    "bqClick": "bqClick";
  }, never, ["*"], false, never>;
}
export declare interface BqAccordion extends Components.BqAccordion {
  /**
   * Handler to be called when the accordion loses focus
   */
  bqBlur: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  /**
   * Handler to be called when the accordion gets focus
   */
  bqFocus: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  /**
   * Handler to be called when the accordion is opened
   */
  bqOpen: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  /**
   * Handler to be called after the accordion is opened
   */
  bqAfterOpen: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  /**
   * Handler to be called when the accordion is closed
   */
  bqClose: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  /**
   * Handler to be called after the accordion is closed
   */
  bqAfterClose: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
  /**
   * Handler to be called when the accordion is clicked
   */
  bqClick: EventEmitter<BqAccordionCustomEvent<HTMLBqAccordionElement>>;
}
export declare class BqAccordionGroup {
  protected z: NgZone;
  protected el: HTMLBqAccordionGroupElement;
  /**
   * The appearance style of accordion to be applied to all accordions @default 'filled'
   */
  set appearance(_: Components.BqAccordionGroup['appearance']);
  /**
   * If true all accordions are expanded
   */
  set expandAll(_: Components.BqAccordionGroup['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. @default false
   */
  set noAnimation(_: Components.BqAccordionGroup['noAnimation']);
  /**
   * If true multiple accordions can be expanded at the same time @default false
   */
  set multiple(_: Components.BqAccordionGroup['multiple']);
  /**
   * The size of accordion to be applied to all accordions @default 'medium'
   */
  set size(_: Components.BqAccordionGroup['size']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqAccordionGroup, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqAccordionGroup, "bq-accordion-group", never, {
    "appearance": {
      "alias": "appearance";
      "required": false;
    };
    "expandAll": {
      "alias": "expandAll";
      "required": false;
    };
    "multiple": {
      "alias": "multiple";
      "required": false;
    };
    "noAnimation": {
      "alias": "noAnimation";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqAccordionGroup extends Components.BqAccordionGroup {}
export declare class BqAlert {
  protected z: NgZone;
  protected el: HTMLBqAlertElement;
  /**
   * If true, the alert will automatically hide after the specified amount of time
   */
  set autoDismiss(_: Components.BqAlert['autoDismiss']);
  /**
   * The corner radius of the alert component @default 's'
   */
  set border(_: Components.BqAlert['border']);
  /**
   * If true, the close button at the top right of the alert won't be shown
   */
  set disableClose(_: Components.BqAlert['disableClose']);
  /**
   * If true, the alert icon won't be shown
   */
  set hideIcon(_: Components.BqAlert['hideIcon']);
  /**
   * If true, the alert will be shown
   */
  set open(_: Components.BqAlert['open']);
  /**
   * The length of time, in milliseconds, after which the alert will close itself. Only valid if `autoDismiss="true"` @default 3000
   */
  set time(_: Components.BqAlert['time']);
  /**
   * Type of Alert @default 'default'
   */
  set type(_: Components.BqAlert['type']);
  /**
   * If true, the alert component will remain fixed at the top of the page, occupying the full viewport
   */
  set sticky(_: Components.BqAlert['sticky']);
  bqHide: EventEmitter<BqAlertCustomEvent<any>>;
  bqShow: EventEmitter<BqAlertCustomEvent<any>>;
  bqAfterShow: EventEmitter<BqAlertCustomEvent<any>>;
  bqAfterHide: EventEmitter<BqAlertCustomEvent<any>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqAlert, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqAlert, "bq-alert", never, {
    "autoDismiss": {
      "alias": "autoDismiss";
      "required": false;
    };
    "border": {
      "alias": "border";
      "required": false;
    };
    "disableClose": {
      "alias": "disableClose";
      "required": false;
    };
    "hideIcon": {
      "alias": "hideIcon";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "sticky": {
      "alias": "sticky";
      "required": false;
    };
    "time": {
      "alias": "time";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {
    "bqHide": "bqHide";
    "bqShow": "bqShow";
    "bqAfterShow": "bqAfterShow";
    "bqAfterHide": "bqAfterHide";
  }, never, ["*"], false, never>;
}
export declare interface BqAlert extends Components.BqAlert {
  /**
   * Callback handler to be called when the alert is hidden
   */
  bqHide: EventEmitter<BqAlertCustomEvent<any>>;
  /**
   * Callback handler to be called when the alert is shown
   */
  bqShow: EventEmitter<BqAlertCustomEvent<any>>;
  /**
   * Callback handler to be called after the alert has been shown
   */
  bqAfterShow: EventEmitter<BqAlertCustomEvent<any>>;
  /**
   * Callback handler to be called after the alert has been hidden
   */
  bqAfterHide: EventEmitter<BqAlertCustomEvent<any>>;
}
export declare class BqAvatar {
  protected z: NgZone;
  protected el: HTMLBqAvatarElement;
  /**
   * Alternate text for the avatar image if the image cannot be displayed
   */
  set altText(_: Components.BqAvatar['altText']);
  /**
   * The image source to load on the avatar (this can be also a base64 encoded image)
   */
  set image(_: Components.BqAvatar['image']);
  /**
   * A text to use for describing the avatar on assistive devices
   */
  set label(_: Components.BqAvatar['label']);
  /**
   * The text to display on avatar
   */
  set initials(_: Components.BqAvatar['initials']);
  /**
   * The shape of the avatar @default 'circle'
   */
  set shape(_: Components.BqAvatar['shape']);
  /**
   * The size of the avatar @default 'medium'
   */
  set size(_: Components.BqAvatar['size']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqAvatar, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqAvatar, "bq-avatar", never, {
    "altText": {
      "alias": "altText";
      "required": false;
    };
    "image": {
      "alias": "image";
      "required": false;
    };
    "initials": {
      "alias": "initials";
      "required": false;
    };
    "label": {
      "alias": "label";
      "required": false;
    };
    "shape": {
      "alias": "shape";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqAvatar extends Components.BqAvatar {}
export declare class BqBadge {
  protected z: NgZone;
  protected el: HTMLBqBadgeElement;
  /**
   * Badge background color. The value should be a valid value of the palette color.
When it changes, set a matching `textColor` (e.g. `text--on-success` for `ui--success`) so the content stays legible.
   */
  set backgroundColor(_: Components.BqBadge['backgroundColor']);
  /**
   * Badge number color. The value should be a valid value of the palette color
   */
  set textColor(_: Components.BqBadge['textColor']);
  /**
   * The size of the badge. Relevant if badge has no content. @default 'small'
   */
  set size(_: Components.BqBadge['size']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqBadge, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqBadge, "bq-badge", never, {
    "backgroundColor": {
      "alias": "backgroundColor";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "textColor": {
      "alias": "textColor";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqBadge extends Components.BqBadge {}
export declare class BqBreadcrumb {
  protected z: NgZone;
  protected el: HTMLBqBreadcrumbElement;
  /**
   * The `aria-label` attribute to describe the type of navigation @default 'Breadcrumbs'
   */
  set label(_: Components.BqBreadcrumb['label']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqBreadcrumb, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqBreadcrumb, "bq-breadcrumb", never, {
    "label": {
      "alias": "label";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqBreadcrumb extends Components.BqBreadcrumb {}
export declare class BqBreadcrumbItem {
  protected z: NgZone;
  protected el: HTMLBqBreadcrumbItemElement;
  /**
   * If set, the breadcrumb item will be rendered as an `<a>` with this `href`, otherwise, a `<button>` will be rendered.
   */
  set href(_: Components.BqBreadcrumbItem['href']);
  /**
   * Where to display the link in the browser context. Relevant only if `href` is set.
   */
  set target(_: Components.BqBreadcrumbItem['target']);
  /**
   * Space-separated link relationship types (e.g. `external`, `nofollow`) applied to the inner `<a>`.
Relevant only if `href` is set. When `target` is set, `noreferrer` and `noopener` are always added.
   */
  set rel(_: Components.BqBreadcrumbItem['rel']);
  bqBlur: EventEmitter<BqBreadcrumbItemCustomEvent<HTMLBqBreadcrumbItemElement>>;
  bqFocus: EventEmitter<BqBreadcrumbItemCustomEvent<HTMLBqBreadcrumbItemElement>>;
  bqClick: EventEmitter<BqBreadcrumbItemCustomEvent<HTMLBqBreadcrumbItemElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqBreadcrumbItem, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqBreadcrumbItem, "bq-breadcrumb-item", never, {
    "href": {
      "alias": "href";
      "required": false;
    };
    "rel": {
      "alias": "rel";
      "required": false;
    };
    "target": {
      "alias": "target";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqFocus": "bqFocus";
    "bqClick": "bqClick";
  }, never, ["*"], false, never>;
}
export declare interface BqBreadcrumbItem extends Components.BqBreadcrumbItem {
  /**
   * Handler to be called when item loses focus
   */
  bqBlur: EventEmitter<BqBreadcrumbItemCustomEvent<HTMLBqBreadcrumbItemElement>>;
  /**
   * Handler to be called when item is focused
   */
  bqFocus: EventEmitter<BqBreadcrumbItemCustomEvent<HTMLBqBreadcrumbItemElement>>;
  /**
   * Handler to be called when item is clicked
   */
  bqClick: EventEmitter<BqBreadcrumbItemCustomEvent<HTMLBqBreadcrumbItemElement>>;
}
export declare class BqButton {
  protected z: NgZone;
  protected el: HTMLBqButtonElement;
  /**
   * The appearance style to apply to the button @default 'primary'
   */
  set appearance(_: Components.BqButton['appearance']);
  /**
   * If `true`, it will make the button fit to its parent width. @default false
   */
  set block(_: Components.BqButton['block']);
  /**
   * The corner radius of the button @default 'm'
   */
  set border(_: Components.BqButton['border']);
  /**
   * If true, the button will be disabled (no interaction allowed) @default false
   */
  set disabled(_: Components.BqButton['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(_: Components.BqButton['download']);
  /**
   * When set, the underlying button will be rendered as an `<a>` with this `href` instead of a `<button>`
   */
  set href(_: Components.BqButton['href']);
  /**
   * It determinate how the content should be aligned @default 'center'
   */
  set justifyContent(_: Components.BqButton['justifyContent']);
  /**
   * Text  used for accessibility purposes, specially screen readers, to describe the button action
   */
  set label(_: Components.BqButton['label']);
  /**
   * If `true` it will display the button in a loading state @default false
   */
  set loading(_: Components.BqButton['loading']);
  /**
   * If `true` it will display the button as an icon-only button with aspect ratio 1:1 (square dimensions). Make sure to set the `label` prop for accessibility purposes. @default false
   */
  set onlyIcon(_: Components.BqButton['onlyIcon']);
  /**
   * The size of the button @default 'medium'
   */
  set size(_: Components.BqButton['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(_: Components.BqButton['target']);
  /**
   * The default behavior of the button @default 'button'
   */
  set type(_: Components.BqButton['type']);
  /**
   * The variant of button to apply on top of the appearance (applicable only to `appearance="primary"`) @default 'standard'
   */
  set variant(_: Components.BqButton['variant']);
  bqBlur: EventEmitter<BqButtonCustomEvent<HTMLBqButtonElement>>;
  bqFocus: EventEmitter<BqButtonCustomEvent<HTMLBqButtonElement>>;
  bqClick: EventEmitter<BqButtonCustomEvent<HTMLBqButtonElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqButton, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqButton, "bq-button", never, {
    "appearance": {
      "alias": "appearance";
      "required": false;
    };
    "block": {
      "alias": "block";
      "required": false;
    };
    "border": {
      "alias": "border";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "download": {
      "alias": "download";
      "required": false;
    };
    "href": {
      "alias": "href";
      "required": false;
    };
    "justifyContent": {
      "alias": "justifyContent";
      "required": false;
    };
    "label": {
      "alias": "label";
      "required": false;
    };
    "loading": {
      "alias": "loading";
      "required": false;
    };
    "onlyIcon": {
      "alias": "onlyIcon";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "target": {
      "alias": "target";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
    "variant": {
      "alias": "variant";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqFocus": "bqFocus";
    "bqClick": "bqClick";
  }, never, ["*"], false, never>;
}
export declare interface BqButton extends Components.BqButton {
  /**
   * Handler to be called when the button loses focus.
   */
  bqBlur: EventEmitter<BqButtonCustomEvent<HTMLBqButtonElement>>;
  /**
   * Handler to be called when the button gets focus.
   */
  bqFocus: EventEmitter<BqButtonCustomEvent<HTMLBqButtonElement>>;
  /**
   * Handler to be called when the button is clicked.
   */
  bqClick: EventEmitter<BqButtonCustomEvent<HTMLBqButtonElement>>;
}
export declare class BqCard {
  protected z: NgZone;
  protected el: HTMLBqCardElement;
  /**
   * Type of card component @default 'default'
   */
  set type(_: Components.BqCard['type']);
  /**
   * The corner radius of the card component @default 'm'
   */
  set border(_: Components.BqCard['border']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqCard, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqCard, "bq-card", never, {
    "border": {
      "alias": "border";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqCard extends Components.BqCard {}
export declare class BqCheckbox {
  protected z: NgZone;
  protected el: HTMLBqCheckboxElement;
  /**
   * If true checkbox displays background on hover @default false
   */
  set backgroundOnHover(_: Components.BqCheckbox['backgroundOnHover']);
  /**
   * The form ID that the checkbox is associated with
   */
  set formId(_: Components.BqCheckbox['formId']);
  /**
   * The native form validation message
   */
  set formValidationMessage(_: Components.BqCheckbox['formValidationMessage']);
  /**
   * If true checkbox is checked
   */
  set checked(_: Components.BqCheckbox['checked']);
  /**
   * If true checkbox is disabled @default false
   */
  set disabled(_: Components.BqCheckbox['disabled']);
  /**
   * A state that is neither checked nor unchecked @default false
   */
  set indeterminate(_: Components.BqCheckbox['indeterminate']);
  /**
   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.
   */
  set name(_: Components.BqCheckbox['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(_: Components.BqCheckbox['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(_: Components.BqCheckbox['value']);
  bqChange: EventEmitter<BqCheckboxCustomEvent<{
    checked: boolean;
  }>>;
  bqFocus: EventEmitter<BqCheckboxCustomEvent<HTMLBqCheckboxElement>>;
  bqBlur: EventEmitter<BqCheckboxCustomEvent<HTMLBqCheckboxElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqCheckbox, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqCheckbox, "bq-checkbox", never, {
    "backgroundOnHover": {
      "alias": "backgroundOnHover";
      "required": false;
    };
    "checked": {
      "alias": "checked";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "formId": {
      "alias": "formId";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "indeterminate": {
      "alias": "indeterminate";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": true;
    };
  }, {
    "bqChange": "bqChange";
    "bqFocus": "bqFocus";
    "bqBlur": "bqBlur";
  }, never, ["*"], false, never>;
}
export declare interface BqCheckbox extends Components.BqCheckbox {
  /**
   * Handler to be called when the checkbox state changes
   */
  bqChange: EventEmitter<BqCheckboxCustomEvent<{
    checked: boolean;
  }>>;
  /**
   * Handler to be called when the checkbox gets focus
   */
  bqFocus: EventEmitter<BqCheckboxCustomEvent<HTMLBqCheckboxElement>>;
  /**
   * Handler to be called when the checkbox loses focus
   */
  bqBlur: EventEmitter<BqCheckboxCustomEvent<HTMLBqCheckboxElement>>;
}
export declare class BqDatePicker {
  protected z: NgZone;
  protected el: HTMLBqDatePickerElement;
  /**
   * If `true`, the Date picker input will be focused on component render. @default false
   */
  set autofocus(_: Components.BqDatePicker['autofocus']);
  /**
   * The clear button aria label. @default 'Clear value'
   */
  set clearButtonLabel(_: Components.BqDatePicker['clearButtonLabel']);
  /**
   * The aria-label for the calendar trigger button. @default 'Open calendar'
   */
  set calendarButtonLabel(_: Components.BqDatePicker['calendarButtonLabel']);
  /**
   * If `true`, the clear button won't be displayed. @default false
   */
  set disableClear(_: Components.BqDatePicker['disableClear']);
  /**
   * Indicates whether the Date picker input is disabled or not. @default false
   */
  set disabled(_: Components.BqDatePicker['disabled']);
  /**
   * Distance (gutter) between the Date picker panel and the input element. @default 8
   */
  set distance(_: Components.BqDatePicker['distance']);
  /**
   * The first day of the week, where Sunday is 0, Monday is 1, etc. @default 1
   */
  set firstDayOfWeek(_: Components.BqDatePicker['firstDayOfWeek']);
  /**
   * Numeric options used to derive the input mask's field order and separators.

The options must contain numeric or two-digit day/month fields and a
numeric year. Textual or variable-length fields fall back to the locale
numeric mask and emit a development warning.
   */
  set formatOptions(_: Components.BqDatePicker['formatOptions']);
  /**
   * The ID of the form the input belongs to.
   */
  set form(_: Components.BqDatePicker['form']);
  /**
   * Native form validation message (mandatory if `required` is set).
   */
  set formValidationMessage(_: Components.BqDatePicker['formValidationMessage']);
  /**
   * The view opened first when the panel becomes visible. @default 'days'
   */
  set initialView(_: Components.BqDatePicker['initialView']);
  /**
   * Predicate that marks specific dates as unselectable.
   */
  set isDateDisallowed(_: Components.BqDatePicker['isDateDisallowed']);
  /**
   * Locale used for formatting dates. @default 'en-GB'
   */
  set locale(_: Components.BqDatePicker['locale']);
  /**
   * Latest date that can be selected (ISO).
   */
  set max(_: Components.BqDatePicker['max']);
  /**
   * Earliest date that can be selected (ISO).
   */
  set min(_: Components.BqDatePicker['min']);
  /**
   * Number of months to show side by side (range / multi). Capped at 2.
Larger values are silently clamped to keep the popover from overflowing
the viewport and to preserve keyboard navigation semantics. @default 1
   */
  set months(_: Components.BqDatePicker['months']);
  /**
   * How the next/previous buttons should navigate the calendar.
- single: navigate one month at a time.
- months: navigate by the number of months displayed. @default 'single'
   */
  set monthsPerView(_: Components.BqDatePicker['monthsPerView']);
  /**
   * The Date picker input name.
   */
  set name(_: Components.BqDatePicker['name']);
  /**
   * If `true`, the panel is visible. @default false
   */
  set open(_: Components.BqDatePicker['open']);
  /**
   * Overrides the height of the Date picker panel. @default 'auto'
   */
  set panelHeight(_: Components.BqDatePicker['panelHeight']);
  /**
   *  @deprecated Locale-derived segment format hints always describe the
expected entry layout, so this value no longer changes the rendered field.
   */
  set placeholder(_: Components.BqDatePicker['placeholder']);
  /**
   * Position of the Date picker panel. @default 'bottom-end'
   */
  set placement(_: Components.BqDatePicker['placement']);
  /**
   * Precision of the value produced by the picker.

- `day`   → `YYYY-MM-DD` (default). Standard drill-down.
- `month` → `YYYY-MM`. Selection commits on the months view; no days view.
- `year`  → `YYYY`. Selection commits on the years view; no months/days view.

When precision is coarser than day, `initialView` is forced to match and
the header title cycles through the views available for that precision. @default 'day'
   */
  set precision(_: Components.BqDatePicker['precision']);
  /**
   * Whether a value must be selected before submitting the form. @default false
   */
  set required(_: Components.BqDatePicker['required']);
  /**
   * Skidding between the panel and the input element. @default 0
   */
  set skidding(_: Components.BqDatePicker['skidding']);
  /**
   * Whether to render days outside the current month. @default false
   */
  set showOutsideDays(_: Components.BqDatePicker['showOutsideDays']);
  /**
   * Positioning strategy for the panel. @default 'fixed'
   */
  set strategy(_: Components.BqDatePicker['strategy']);
  /**
   * Selection type.
- `single`: single date.
- `multi`: multiple discrete dates.
- `range`: contiguous range. @default 'single'
   */
  set type(_: Components.BqDatePicker['type']);
  /**
   * Validation state applied to the input. @default 'none'
   */
  set validationStatus(_: Components.BqDatePicker['validationStatus']);
  /**
   * Currently selected value, in the precision-aware wire format:
- `precision="day"`   → tokens are `YYYY-MM-DD`
- `precision="month"` → tokens are `YYYY-MM`
- `precision="year"`  → tokens are `YYYY`

How multiple tokens are combined depends on `type`:
- `single` → a single token (e.g. `"2025-05-15"`, `"2025-05"`, `"2025"`)
- `range`  → `"start/end"` — two tokens joined with `/`
- `multi`  → space-separated tokens (e.g. `"2025-05-15 2025-05-20"`)
   */
  set value(_: Components.BqDatePicker['value']);
  bqBlur: EventEmitter<BqDatePickerCustomEvent<HTMLBqDatePickerElement>>;
  bqChange: EventEmitter<BqDatePickerCustomEvent<{
    value: string | undefined;
    el: HTMLBqDatePickerElement;
  }>>;
  bqClear: EventEmitter<BqDatePickerCustomEvent<HTMLBqDatePickerElement>>;
  bqFocus: EventEmitter<BqDatePickerCustomEvent<HTMLBqDatePickerElement>>;
  bqViewChange: EventEmitter<BqDatePickerCustomEvent<{
    view: TCalendarView;
    el: HTMLBqDatePickerElement;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqDatePicker, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqDatePicker, "bq-date-picker", never, {
    "autofocus": {
      "alias": "autofocus";
      "required": false;
    };
    "calendarButtonLabel": {
      "alias": "calendarButtonLabel";
      "required": false;
    };
    "clearButtonLabel": {
      "alias": "clearButtonLabel";
      "required": false;
    };
    "disableClear": {
      "alias": "disableClear";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "distance": {
      "alias": "distance";
      "required": false;
    };
    "firstDayOfWeek": {
      "alias": "firstDayOfWeek";
      "required": false;
    };
    "form": {
      "alias": "form";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "formatOptions": {
      "alias": "formatOptions";
      "required": false;
    };
    "initialView": {
      "alias": "initialView";
      "required": false;
    };
    "isDateDisallowed": {
      "alias": "isDateDisallowed";
      "required": false;
    };
    "locale": {
      "alias": "locale";
      "required": false;
    };
    "max": {
      "alias": "max";
      "required": false;
    };
    "min": {
      "alias": "min";
      "required": false;
    };
    "months": {
      "alias": "months";
      "required": false;
    };
    "monthsPerView": {
      "alias": "monthsPerView";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "panelHeight": {
      "alias": "panelHeight";
      "required": false;
    };
    "placeholder": {
      "alias": "placeholder";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "precision": {
      "alias": "precision";
      "required": false;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "showOutsideDays": {
      "alias": "showOutsideDays";
      "required": false;
    };
    "skidding": {
      "alias": "skidding";
      "required": false;
    };
    "strategy": {
      "alias": "strategy";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
    "validationStatus": {
      "alias": "validationStatus";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqChange": "bqChange";
    "bqClear": "bqClear";
    "bqFocus": "bqFocus";
    "bqViewChange": "bqViewChange";
  }, never, ["*"], false, never>;
}
export declare interface BqDatePicker extends Components.BqDatePicker {
  /**
   * Callback handler emitted when the input loses focus.
   */
  bqBlur: EventEmitter<BqDatePickerCustomEvent<HTMLBqDatePickerElement>>;
  /**
   * Callback handler emitted when the input value changes.
   */
  bqChange: EventEmitter<BqDatePickerCustomEvent<{
    value: string | undefined;
    el: HTMLBqDatePickerElement;
  }>>;
  /**
   * Callback handler emitted when the value is cleared.
   */
  bqClear: EventEmitter<BqDatePickerCustomEvent<HTMLBqDatePickerElement>>;
  /**
   * Callback handler emitted when the input receives focus.
   */
  bqFocus: EventEmitter<BqDatePickerCustomEvent<HTMLBqDatePickerElement>>;
  /**
     * Callback handler emitted when the internal calendar view changes
  (e.g. from `days` to `months`, or from `years` back to `days`).
     */
  bqViewChange: EventEmitter<BqDatePickerCustomEvent<{
    view: TCalendarView;
    el: HTMLBqDatePickerElement;
  }>>;
}
export declare class BqDialog {
  protected z: NgZone;
  protected el: HTMLBqDialogElement;
  /**
   * Border radius of the dialog component @default 'm'
   */
  set border(_: Components.BqDialog['border']);
  /**
   * If true, the backdrop overlay won't be shown when the dialog opens @default false
   */
  set disableBackdrop(_: Components.BqDialog['disableBackdrop']);
  /**
   * If true, the dialog will not close when the [Esc] key is press @default false
   */
  set disableCloseEscKeydown(_: Components.BqDialog['disableCloseEscKeydown']);
  /**
   * If true, the dialog will not close when clicking on the backdrop overlay @default false
   */
  set disableCloseClickOutside(_: Components.BqDialog['disableCloseClickOutside']);
  /**
   * The appearance of footer @default 'standard'
   */
  set footerAppearance(_: Components.BqDialog['footerAppearance']);
  /**
   * If true, it hides the close button @default false
   */
  set hideCloseButton(_: Components.BqDialog['hideCloseButton']);
  /**
   * If true, the dialog will be shown as open @default false
   */
  set open(_: Components.BqDialog['open']);
  /**
   * The size of the dialog @default 'medium'
   */
  set size(_: Components.BqDialog['size']);
  bqCancel: EventEmitter<BqDialogCustomEvent<void>>;
  bqClose: EventEmitter<BqDialogCustomEvent<void>>;
  bqOpen: EventEmitter<BqDialogCustomEvent<void>>;
  bqAfterOpen: EventEmitter<BqDialogCustomEvent<void>>;
  bqAfterClose: EventEmitter<BqDialogCustomEvent<void>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqDialog, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqDialog, "bq-dialog", never, {
    "border": {
      "alias": "border";
      "required": false;
    };
    "disableBackdrop": {
      "alias": "disableBackdrop";
      "required": false;
    };
    "disableCloseClickOutside": {
      "alias": "disableCloseClickOutside";
      "required": false;
    };
    "disableCloseEscKeydown": {
      "alias": "disableCloseEscKeydown";
      "required": false;
    };
    "footerAppearance": {
      "alias": "footerAppearance";
      "required": false;
    };
    "hideCloseButton": {
      "alias": "hideCloseButton";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
  }, {
    "bqCancel": "bqCancel";
    "bqClose": "bqClose";
    "bqOpen": "bqOpen";
    "bqAfterOpen": "bqAfterOpen";
    "bqAfterClose": "bqAfterClose";
  }, never, ["*"], false, never>;
}
export declare interface BqDialog extends Components.BqDialog {
  /**
   * Callback handler emitted when the dialog has been canceled or dismissed
   */
  bqCancel: EventEmitter<BqDialogCustomEvent<void>>;
  /**
   * Callback handler emitted when the dialog will close
   */
  bqClose: EventEmitter<BqDialogCustomEvent<void>>;
  /**
   * Callback handler emitted when the dialog will open
   */
  bqOpen: EventEmitter<BqDialogCustomEvent<void>>;
  /**
   * Callback handler emitted when the dialog finish opening
   */
  bqAfterOpen: EventEmitter<BqDialogCustomEvent<void>>;
  /**
   * Callback handler emitted when the dialog finish closing
   */
  bqAfterClose: EventEmitter<BqDialogCustomEvent<void>>;
}
export declare class BqDivider {
  protected z: NgZone;
  protected el: HTMLBqDividerElement;
  /**
   * If true, the divider has a dashed pattern @default false
   */
  set dashed(_: Components.BqDivider['dashed']);
  /**
   * The default orientation of the divider @default 'horizontal'
   */
  set orientation(_: Components.BqDivider['orientation']);
  /**
   * Set the stroke color of the divider. The value should be a valid value of the palette color @default 'stroke--primary'
   */
  set strokeColor(_: Components.BqDivider['strokeColor']);
  /**
   * Set the alignment of the title on the main axis of the divider (horizontal / vertical) @default 'middle'
   */
  set titleAlignment(_: Components.BqDivider['titleAlignment']);
  /**
   * Set the width of each dash of the divider's stroke. This is applicable when the stroke is dashed @default 12
   */
  set strokeDashWidth(_: Components.BqDivider['strokeDashWidth']);
  /**
   * Set the gap of the divider's stroke. This is applicable when the stroke is dashed @default 7
   */
  set strokeDashGap(_: Components.BqDivider['strokeDashGap']);
  /**
   * Set the thickness of the divider's stroke. Value expressed in px @default 1
   */
  set strokeThickness(_: Components.BqDivider['strokeThickness']);
  /**
   * Set the min width of the divider's stroke when text is not centered. Value expressed in px @default 0
   */
  set strokeBasis(_: Components.BqDivider['strokeBasis']);
  /**
   * Set the line of the divider's stroke. This is applicable when the stroke is dashed @default 'butt'
   */
  set strokeLinecap(_: Components.BqDivider['strokeLinecap']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqDivider, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqDivider, "bq-divider", never, {
    "dashed": {
      "alias": "dashed";
      "required": false;
    };
    "orientation": {
      "alias": "orientation";
      "required": false;
    };
    "strokeBasis": {
      "alias": "strokeBasis";
      "required": false;
    };
    "strokeColor": {
      "alias": "strokeColor";
      "required": false;
    };
    "strokeDashGap": {
      "alias": "strokeDashGap";
      "required": false;
    };
    "strokeDashWidth": {
      "alias": "strokeDashWidth";
      "required": false;
    };
    "strokeLinecap": {
      "alias": "strokeLinecap";
      "required": false;
    };
    "strokeThickness": {
      "alias": "strokeThickness";
      "required": false;
    };
    "titleAlignment": {
      "alias": "titleAlignment";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqDivider extends Components.BqDivider {}
export declare class BqDrawer {
  protected z: NgZone;
  protected el: HTMLBqDrawerElement;
  /**
   * If true, the backdrop overlay will be shown when the drawer opens @default false
   */
  set enableBackdrop(_: Components.BqDrawer['enableBackdrop']);
  /**
   * If true, the drawer will not close when clicking outside the panel @default false
   */
  set closeOnClickOutside(_: Components.BqDrawer['closeOnClickOutside']);
  /**
   * If true, the dialog will not close when the [Esc] key is pressed @default false
   */
  set closeOnEsc(_: Components.BqDrawer['closeOnEsc']);
  /**
   * If true, the drawer component will be shown
   */
  set open(_: Components.BqDrawer['open']);
  /**
   *  @deprecated Defines the position of the drawer,@default 'right'
   */
  set placement(_: Components.BqDrawer['placement']);
  /**
   * Defines the position of the drawer @default 'end'
   */
  set position(_: Components.BqDrawer['position']);
  bqClose: EventEmitter<BqDrawerCustomEvent<any>>;
  bqOpen: EventEmitter<BqDrawerCustomEvent<any>>;
  bqAfterOpen: EventEmitter<BqDrawerCustomEvent<any>>;
  bqAfterClose: EventEmitter<BqDrawerCustomEvent<any>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqDrawer, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqDrawer, "bq-drawer", never, {
    "closeOnClickOutside": {
      "alias": "closeOnClickOutside";
      "required": false;
    };
    "closeOnEsc": {
      "alias": "closeOnEsc";
      "required": false;
    };
    "enableBackdrop": {
      "alias": "enableBackdrop";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "position": {
      "alias": "position";
      "required": false;
    };
  }, {
    "bqClose": "bqClose";
    "bqOpen": "bqOpen";
    "bqAfterOpen": "bqAfterOpen";
    "bqAfterClose": "bqAfterClose";
  }, never, ["*"], false, never>;
}
export declare interface BqDrawer extends Components.BqDrawer {
  /**
   * Callback handler to be called when the drawer is closed
   */
  bqClose: EventEmitter<BqDrawerCustomEvent<any>>;
  /**
   * Callback handler to be called when the drawer is opened
   */
  bqOpen: EventEmitter<BqDrawerCustomEvent<any>>;
  /**
   * Callback handler to be called after the drawer has been opened
   */
  bqAfterOpen: EventEmitter<BqDrawerCustomEvent<any>>;
  /**
   * Callback handler to be called after the drawer has been closed
   */
  bqAfterClose: EventEmitter<BqDrawerCustomEvent<any>>;
}
export declare class BqDropdown {
  protected z: NgZone;
  protected el: HTMLBqDropdownElement;
  /**
   * If true, the dropdown panel will not lock the page body scroll when open. @default false
   */
  set disableScrollLock(_: Components.BqDropdown['disableScrollLock']);
  /**
   * If true, the dropdown panel will be visible and won't be shown. @default false
   */
  set disabled(_: Components.BqDropdown['disabled']);
  /**
   * Represents the distance (gutter or margin) between the panel and the trigger element. @default 4
   */
  set distance(_: Components.BqDropdown['distance']);
  /**
   * If true, the panel will remain open after a selection is made. @default false
   */
  set keepOpenOnSelect(_: Components.BqDropdown['keepOpenOnSelect']);
  /**
   * Position of the panel @default 'bottom-start'
   */
  set placement(_: Components.BqDropdown['placement']);
  /**
   * If true, the panel will be visible. @default false
   */
  set open(_: Components.BqDropdown['open']);
  /**
   * When set, it will override the height of the dropdown panel
   */
  set panelHeight(_: Components.BqDropdown['panelHeight']);
  /**
   * Whether the panel should have the same width as the trigger element @default false
   */
  set sameWidth(_: Components.BqDropdown['sameWidth']);
  /**
   * Represents the skidding between the panel and the trigger element. @default 0
   */
  set skidding(_: Components.BqDropdown['skidding']);
  /**
   * Defines the strategy to position the panel @default 'fixed'
   */
  set strategy(_: Components.BqDropdown['strategy']);
  bqOpen: EventEmitter<BqDropdownCustomEvent<{
    open: boolean;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqDropdown, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqDropdown, "bq-dropdown", never, {
    "disableScrollLock": {
      "alias": "disableScrollLock";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "distance": {
      "alias": "distance";
      "required": false;
    };
    "keepOpenOnSelect": {
      "alias": "keepOpenOnSelect";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "panelHeight": {
      "alias": "panelHeight";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "sameWidth": {
      "alias": "sameWidth";
      "required": false;
    };
    "skidding": {
      "alias": "skidding";
      "required": false;
    };
    "strategy": {
      "alias": "strategy";
      "required": false;
    };
  }, {
    "bqOpen": "bqOpen";
  }, never, ["*"], false, never>;
}
export declare interface BqDropdown extends Components.BqDropdown {
  /**
   * Callback handler to be called when the dropdown panel is opened or closed.
   */
  bqOpen: EventEmitter<BqDropdownCustomEvent<{
    open: boolean;
  }>>;
}
export declare class BqEmptyState {
  protected z: NgZone;
  protected el: HTMLBqEmptyStateElement;
  /**
   * The size of the empty state component @default 'medium'
   */
  set size(_: Components.BqEmptyState['size']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqEmptyState, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqEmptyState, "bq-empty-state", never, {
    "size": {
      "alias": "size";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqEmptyState extends Components.BqEmptyState {}
export declare class BqIcon {
  protected z: NgZone;
  protected el: HTMLBqIconElement;
  /**
   * Label for the icon, used for accessibility
   */
  set label(_: Components.BqIcon['label']);
  /**
   * Set the stroke color of the SVG. The value should be a valid value of the palette color
   */
  set color(_: Components.BqIcon['color']);
  /**
   * Icon name to load. Please check all available icons [here](https://phosphoricons.com/)
   */
  set name(_: Components.BqIcon['name']);
  /**
   * Set the size of the SVG @default 24
   */
  set size(_: Components.BqIcon['size']);
  /**
   * Set the source of the SVG. If the source is set, the name property will be ignored
   */
  set src(_: Components.BqIcon['src']);
  /**
   *  @deprecated It set the icon weight/style,@default undefined
   */
  set weight(_: Components.BqIcon['weight']);
  svgLoaded: EventEmitter<BqIconCustomEvent<any>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqIcon, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqIcon, "bq-icon", never, {
    "color": {
      "alias": "color";
      "required": false;
    };
    "label": {
      "alias": "label";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "src": {
      "alias": "src";
      "required": false;
    };
    "weight": {
      "alias": "weight";
      "required": false;
    };
  }, {
    "svgLoaded": "svgLoaded";
  }, never, ["*"], false, never>;
}
export declare interface BqIcon extends Components.BqIcon {
  /**
   * Callback handler to be called when the SVG has loaded
   */
  svgLoaded: EventEmitter<BqIconCustomEvent<any>>;
}
export declare class BqInput {
  protected z: NgZone;
  protected el: HTMLBqInputElement;
  /**
   * 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,@default 'off'
   */
  set autocapitalize(_: Components.BqInput['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,@default 'off'
   */
  set autocomplete(_: Components.BqInput['autocomplete']);
  /**
   * If true, the input will be focused on component render @default false
   */
  set autofocus(_: Components.BqInput['autofocus']);
  /**
   * The clear button aria label @default 'Clear value'
   */
  set clearButtonLabel(_: Components.BqInput['clearButtonLabel']);
  /**
   * The amount of time, in milliseconds, to wait before emitting the `bqInput` event after the input value changes.
With `0` (default), the event is emitted synchronously. @default 0
   */
  set debounceTime(_: Components.BqInput['debounceTime']);
  /**
   * Indicates whether the input is disabled or not.
If `true`, the input is disabled and cannot be interacted with. @default false
   */
  set disabled(_: Components.BqInput['disabled']);
  /**
   * If true, the clear button won't be displayed @default false
   */
  set disableClear(_: Components.BqInput['disableClear']);
  /**
   * The ID of the form that the input field belongs to.
   */
  set form(_: Components.BqInput['form']);
  /**
   * The native form validation message (mandatory if `required` is set)
   */
  set formValidationMessage(_: Components.BqInput['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(_: Components.BqInput['inputmode']);
  /**
   * The maximum value that the input field can accept.
Only applies to date and number input types.
   */
  set max(_: Components.BqInput['max']);
  /**
   * The maximum number of characters that the input field can accept.
   */
  set maxlength(_: Components.BqInput['maxlength']);
  /**
   * The minimum value that the input field can accept.
Only applies to date and number input types.
   */
  set min(_: Components.BqInput['min']);
  /**
   * The minimum number of characters that the input field can accept.
   */
  set minlength(_: Components.BqInput['minlength']);
  /**
   * The input field name.
   */
  set name(_: Components.BqInput['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(_: Components.BqInput['pattern']);
  /**
   * The input placeholder text value
   */
  set placeholder(_: Components.BqInput['placeholder']);
  /**
   * If true, the input field cannot be modified.
   */
  set readonly(_: Components.BqInput['readonly']);
  /**
   * Indicates whether or not the input field is required to be filled out before submitting the form.
   */
  set required(_: Components.BqInput['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(_: Components.BqInput['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,@default 'text'
   */
  set type(_: Components.BqInput['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.,@default 'none'
   */
  set validationStatus(_: Components.BqInput['validationStatus']);
  /**
   * The input value, it can be used to reset the input to a previous value.
User-entered number values are numbers; empty or incomplete numeric input and Clear use an empty string.
   */
  set value(_: Components.BqInput['value']);
  bqBlur: EventEmitter<BqInputCustomEvent<HTMLBqInputElement>>;
  bqChange: EventEmitter<BqInputCustomEvent<{
    value: string | number | string[];
    el: HTMLBqInputElement;
  }>>;
  bqClear: EventEmitter<BqInputCustomEvent<HTMLBqInputElement>>;
  bqFocus: EventEmitter<BqInputCustomEvent<HTMLBqInputElement>>;
  bqInput: EventEmitter<BqInputCustomEvent<{
    value: string | number | string[];
    el: HTMLBqInputElement;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqInput, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqInput, "bq-input", never, {
    "autocapitalize": {
      "alias": "autocapitalize";
      "required": false;
    };
    "autocomplete": {
      "alias": "autocomplete";
      "required": false;
    };
    "autofocus": {
      "alias": "autofocus";
      "required": false;
    };
    "clearButtonLabel": {
      "alias": "clearButtonLabel";
      "required": false;
    };
    "debounceTime": {
      "alias": "debounceTime";
      "required": false;
    };
    "disableClear": {
      "alias": "disableClear";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "form": {
      "alias": "form";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "inputmode": {
      "alias": "inputmode";
      "required": false;
    };
    "max": {
      "alias": "max";
      "required": false;
    };
    "maxlength": {
      "alias": "maxlength";
      "required": false;
    };
    "min": {
      "alias": "min";
      "required": false;
    };
    "minlength": {
      "alias": "minlength";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "pattern": {
      "alias": "pattern";
      "required": false;
    };
    "placeholder": {
      "alias": "placeholder";
      "required": false;
    };
    "readonly": {
      "alias": "readonly";
      "required": false;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "step": {
      "alias": "step";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
    "validationStatus": {
      "alias": "validationStatus";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqChange": "bqChange";
    "bqClear": "bqClear";
    "bqFocus": "bqFocus";
    "bqInput": "bqInput";
  }, never, ["*"], false, never>;
}
export declare interface BqInput extends Components.BqInput {
  /**
   * Callback handler emitted when the input loses focus
   */
  bqBlur: EventEmitter<BqInputCustomEvent<HTMLBqInputElement>>;
  /**
     * Callback handler emitted when the input value has changed and the input loses focus.
  This handler is called whenever the user finishes typing or pasting text into the input field and then clicks outside of the input field.
  Numeric input emits a number when complete and an empty string when empty or incomplete.
     */
  bqChange: EventEmitter<BqInputCustomEvent<{
    value: string | number | string[];
    el: HTMLBqInputElement;
  }>>;
  /**
   * Callback handler emitted when the input value has been cleared
   */
  bqClear: EventEmitter<BqInputCustomEvent<HTMLBqInputElement>>;
  /**
   * Callback handler emitted when the input has received focus
   */
  bqFocus: EventEmitter<BqInputCustomEvent<HTMLBqInputElement>>;
  /**
     * Callback handler emitted when the input value changes.
  This handler is called whenever the user types or pastes text into the input field.
  Numeric input emits a number when complete and an empty string when empty or incomplete.
     */
  bqInput: EventEmitter<BqInputCustomEvent<{
    value: string | number | string[];
    el: HTMLBqInputElement;
  }>>;
}
export declare class BqNotification {
  protected z: NgZone;
  protected el: HTMLBqNotificationElement;
  /**
   * If true, the notification will automatically hide after the specified amount of time
   */
  set autoDismiss(_: Components.BqNotification['autoDismiss']);
  /**
   * The corder radius of the notification component @default 's'
   */
  set border(_: Components.BqNotification['border']);
  /**
   * If true, the close button at the top right of the notification won't be shown
   */
  set disableClose(_: Components.BqNotification['disableClose']);
  /**
   * If true, the notification icon won't be shown
   */
  set hideIcon(_: Components.BqNotification['hideIcon']);
  /**
   * If true, the notification will be shown
   */
  set open(_: Components.BqNotification['open']);
  /**
   * The length of time, in milliseconds, after which the notification will close itself. Only valid if `autoDismiss="true"` @default 3000
   */
  set time(_: Components.BqNotification['time']);
  /**
   * Type of Notification @default 'info'
   */
  set type(_: Components.BqNotification['type']);
  bqHide: EventEmitter<BqNotificationCustomEvent<any>>;
  bqShow: EventEmitter<BqNotificationCustomEvent<any>>;
  bqAfterOpen: EventEmitter<BqNotificationCustomEvent<any>>;
  bqAfterClose: EventEmitter<BqNotificationCustomEvent<any>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqNotification, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqNotification, "bq-notification", never, {
    "autoDismiss": {
      "alias": "autoDismiss";
      "required": false;
    };
    "border": {
      "alias": "border";
      "required": false;
    };
    "disableClose": {
      "alias": "disableClose";
      "required": false;
    };
    "hideIcon": {
      "alias": "hideIcon";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "time": {
      "alias": "time";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {
    "bqHide": "bqHide";
    "bqShow": "bqShow";
    "bqAfterOpen": "bqAfterOpen";
    "bqAfterClose": "bqAfterClose";
  }, never, ["*"], false, never>;
}
export declare interface BqNotification extends Components.BqNotification {
  /**
   * Callback handler to be called when the notification is hidden
   */
  bqHide: EventEmitter<BqNotificationCustomEvent<any>>;
  /**
   * Callback handler to be called when the notification is shown
   */
  bqShow: EventEmitter<BqNotificationCustomEvent<any>>;
  /**
   * Callback handler to be called after the notification has been opened
   */
  bqAfterOpen: EventEmitter<BqNotificationCustomEvent<any>>;
  /**
   * Callback handler to be called after the notification has been closed
   */
  bqAfterClose: EventEmitter<BqNotificationCustomEvent<any>>;
}
export declare class BqOption {
  protected z: NgZone;
  protected el: HTMLBqOptionElement;
  /**
   * If true, the option is hidden. @default false
   */
  set hidden(_: Components.BqOption['hidden']);
  /**
   * If true, the option is disabled. @default false
   */
  set disabled(_: Components.BqOption['disabled']);
  /**
   * If true, the option renders as a checkbox option. @default false
   */
  set checkbox(_: Components.BqOption['checkbox']);
  /**
   * The display value of the option. It can be used to override the default displayed value.
   */
  set displayValue(_: Components.BqOption['displayValue']);
  /**
   * If true, nested options are displayed. @default false
   */
  set expanded(_: Components.BqOption['expanded']);
  /**
   * If true, the option checkbox represents a partial nested selection. @default false
   */
  set indeterminate(_: Components.BqOption['indeterminate']);
  /**
   * Text displayed when all selectable nested options are selected. @default 'All selected'
   */
  set allSelectedLabel(_: Components.BqOption['allSelectedLabel']);
  /**
   * Text displayed when some selectable nested options are selected. Use `{count}` as the selected option count placeholder. @default '{count} selected'
   */
  set selectedCountLabel(_: Components.BqOption['selectedCountLabel']);
  /**
   * If true, displays the nested selection summary beside the expand control. @default true
   */
  set showSelectionSummary(_: Components.BqOption['showSelectionSummary']);
  /**
   * If true, the option is selected and active. @default false
   */
  set selected(_: Components.BqOption['selected']);
  /**
   * A string representing the value of the option. Can be used to identify the item
   */
  set value(_: Components.BqOption['value']);
  bqBlur: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  bqFocus: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  bqClick: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  bqEnter: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqOption, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqOption, "bq-option", never, {
    "allSelectedLabel": {
      "alias": "allSelectedLabel";
      "required": false;
    };
    "checkbox": {
      "alias": "checkbox";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "displayValue": {
      "alias": "displayValue";
      "required": false;
    };
    "expanded": {
      "alias": "expanded";
      "required": false;
    };
    "hidden": {
      "alias": "hidden";
      "required": false;
    };
    "indeterminate": {
      "alias": "indeterminate";
      "required": false;
    };
    "selected": {
      "alias": "selected";
      "required": false;
    };
    "selectedCountLabel": {
      "alias": "selectedCountLabel";
      "required": false;
    };
    "showSelectionSummary": {
      "alias": "showSelectionSummary";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqFocus": "bqFocus";
    "bqClick": "bqClick";
    "bqEnter": "bqEnter";
  }, never, ["*"], false, never>;
}
export declare interface BqOption extends Components.BqOption {
  /**
   * Handler to be called when item loses focus
   */
  bqBlur: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  /**
   * Handler to be called when item is focused
   */
  bqFocus: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  /**
   * Handler to be called when item is clicked
   */
  bqClick: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
  /**
   * Emitted when Enter or Space activates a focused option. Checkbox control activation emits bqClick instead.
   */
  bqEnter: EventEmitter<BqOptionCustomEvent<HTMLBqOptionElement>>;
}
export declare class BqOptionGroup {
  protected z: NgZone;
  protected el: HTMLBqOptionGroupElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqOptionGroup, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqOptionGroup, "bq-option-group", never, {}, {}, never, ["*"], false, never>;
}
export declare interface BqOptionGroup extends Components.BqOptionGroup {}
export declare class BqOptionList {
  protected z: NgZone;
  protected el: HTMLBqOptionListElement;
  /**
   * Aria label for the list. @default 'Options'
   */
  set ariaLabel(_: Components.BqOptionList['ariaLabel']);
  bqSelect: EventEmitter<BqOptionListCustomEvent<{
    value: string;
    item: HTMLBqOptionElement;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqOptionList, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqOptionList, "bq-option-list", never, {
    "ariaLabel": {
      "alias": "ariaLabel";
      "required": false;
    };
  }, {
    "bqSelect": "bqSelect";
  }, never, ["*"], false, never>;
}
export declare interface BqOptionList extends Components.BqOptionList {
  /**
   * Handler to be called when `bq-option` is selected (on click/enter press).
   */
  bqSelect: EventEmitter<BqOptionListCustomEvent<{
    value: string;
    item: HTMLBqOptionElement;
  }>>;
}
export declare class BqPageTitle {
  protected z: NgZone;
  protected el: HTMLBqPageTitleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqPageTitle, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqPageTitle, "bq-page-title", never, {}, {}, never, ["*"], false, never>;
}
export declare interface BqPageTitle extends Components.BqPageTitle {}
export declare class BqPanel {
  protected z: NgZone;
  protected el: HTMLBqPanelElement;
  /**
   * If true, the panel will not lock the page body scroll when open. @default false
   */
  set disableScrollLock(_: Components.BqPanel['disableScrollLock']);
  /**
   * Represents the distance (gutter or margin) between the panel and the trigger element. @default 4
   */
  set distance(_: Components.BqPanel['distance']);
  /**
   * Position of the panel @default 'bottom-start'
   */
  set placement(_: Components.BqPanel['placement']);
  /**
   * If true, the panel will be visible. @default false
   */
  set open(_: Components.BqPanel['open']);
  /**
   * Whether the panel should have the same width as the trigger element @default false
   */
  set sameWidth(_: Components.BqPanel['sameWidth']);
  /**
   * Represents the skidding between the panel and the trigger element. @default 0
   */
  set skidding(_: Components.BqPanel['skidding']);
  /**
   * Defines the strategy to position the panel @default 'fixed'
   */
  set strategy(_: Components.BqPanel['strategy']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqPanel, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqPanel, "bq-panel", never, {
    "disableScrollLock": {
      "alias": "disableScrollLock";
      "required": false;
    };
    "distance": {
      "alias": "distance";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "sameWidth": {
      "alias": "sameWidth";
      "required": false;
    };
    "skidding": {
      "alias": "skidding";
      "required": false;
    };
    "strategy": {
      "alias": "strategy";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqPanel extends Components.BqPanel {}
export declare class BqProgress {
  protected z: NgZone;
  protected el: HTMLBqProgressElement;
  /**
   * It will set the border style of the progress bar @default 'rounded'
   */
  set borderShape(_: Components.BqProgress['borderShape']);
  /**
   * If `true`, a tooltip will be shown displaying the progress value @default false
   */
  set enableTooltip(_: Components.BqProgress['enableTooltip']);
  /**
   * If `true` the indeterminate state of progress bar is enabled @default false
   */
  set indeterminate(_: Components.BqProgress['indeterminate']);
  /**
   * If `true, a label text showing the value (in percentage) will be shown @default false
   */
  set label(_: Components.BqProgress['label']);
  /**
   * Progress bar thickness @default 'medium'
   */
  set thickness(_: Components.BqProgress['thickness']);
  /**
   * Progress type @default 'default'
   */
  set type(_: Components.BqProgress['type']);
  /**
   * A number representing the current value of the progress bar @default 0
   */
  set value(_: Components.BqProgress['value']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqProgress, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqProgress, "bq-progress", never, {
    "borderShape": {
      "alias": "borderShape";
      "required": false;
    };
    "enableTooltip": {
      "alias": "enableTooltip";
      "required": false;
    };
    "indeterminate": {
      "alias": "indeterminate";
      "required": false;
    };
    "label": {
      "alias": "label";
      "required": false;
    };
    "thickness": {
      "alias": "thickness";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqProgress extends Components.BqProgress {}
export declare class BqRadio {
  protected z: NgZone;
  protected el: HTMLBqRadioElement;
  /**
   * If true radio displays background on hover @default false
   */
  set backgroundOnHover(_: Components.BqRadio['backgroundOnHover']);
  /**
   * If true radio input is checked @default false
   */
  set checked(_: Components.BqRadio['checked']);
  /**
   * If true radio input is disabled @default false
   */
  set disabled(_: Components.BqRadio['disabled']);
  /**
   * The form ID that the radio input is associated with
   */
  set formId(_: Components.BqRadio['formId']);
  /**
   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.
   */
  set name(_: Components.BqRadio['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(_: Components.BqRadio['required']);
  /**
   * A string representing the value of the radio.
   */
  set value(_: Components.BqRadio['value']);
  bqClick: EventEmitter<BqRadioCustomEvent<{
    value: string;
    target: HTMLBqRadioElement;
  }>>;
  bqFocus: EventEmitter<BqRadioCustomEvent<HTMLBqRadioElement>>;
  bqBlur: EventEmitter<BqRadioCustomEvent<HTMLBqRadioElement>>;
  bqKeyDown: EventEmitter<BqRadioCustomEvent<{
    key: string;
    target: HTMLBqRadioElement;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqRadio, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqRadio, "bq-radio", never, {
    "backgroundOnHover": {
      "alias": "backgroundOnHover";
      "required": false;
    };
    "checked": {
      "alias": "checked";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "formId": {
      "alias": "formId";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": true;
    };
  }, {
    "bqClick": "bqClick";
    "bqFocus": "bqFocus";
    "bqBlur": "bqBlur";
    "bqKeyDown": "bqKeyDown";
  }, never, ["*"], false, never>;
}
export declare interface BqRadio extends Components.BqRadio {
  /**
   * Handler to be called when the radio state changes
   */
  bqClick: EventEmitter<BqRadioCustomEvent<{
    value: string;
    target: HTMLBqRadioElement;
  }>>;
  /**
   * Handler to be called when the radio gets focus
   */
  bqFocus: EventEmitter<BqRadioCustomEvent<HTMLBqRadioElement>>;
  /**
   * Handler to be called when the radio loses focus
   */
  bqBlur: EventEmitter<BqRadioCustomEvent<HTMLBqRadioElement>>;
  /**
   * Handler to be called when the radio key is pressed
   */
  bqKeyDown: EventEmitter<BqRadioCustomEvent<{
    key: string;
    target: HTMLBqRadioElement;
  }>>;
}
export declare class BqRadioGroup {
  protected z: NgZone;
  protected el: HTMLBqRadioGroupElement;
  /**
   * If true, all radio inputs in the group will display a background on hover @default false
   */
  set backgroundOnHover(_: Components.BqRadioGroup['backgroundOnHover']);
  /**
   * A number representing the delay time (in milliseconds) that `bqChange` event handler gets triggered once the value change.
With `0` (default), the event is emitted synchronously. @default 0
   */
  set debounceTime(_: Components.BqRadioGroup['debounceTime']);
  /**
   * If true radio inputs are disabled @default false
   */
  set disabled(_: Components.BqRadioGroup['disabled']);
  /**
   * If true displays fieldset @default false
   */
  set fieldset(_: Components.BqRadioGroup['fieldset']);
  /**
   * Name of the HTML input form control. Submitted with the form as part of a name/value pair.
   */
  set name(_: Components.BqRadioGroup['name']);
  /**
   * The display orientation of the radio inputs @default 'vertical'
   */
  set orientation(_: Components.BqRadioGroup['orientation']);
  /**
   * If true, the radio group is required @default false
   */
  set required(_: Components.BqRadioGroup['required']);
  /**
   * The native form validation message when the radio group is required
   */
  set requiredValidationMessage(_: Components.BqRadioGroup['requiredValidationMessage']);
  /**
   * A string representing the value of the radio.
   */
  set value(_: Components.BqRadioGroup['value']);
  bqChange: EventEmitter<BqRadioGroupCustomEvent<{
    value: string;
    target: HTMLBqRadioElement;
  }>>;
  bqBlur: EventEmitter<BqRadioGroupCustomEvent<HTMLBqRadioElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqRadioGroup, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqRadioGroup, "bq-radio-group", never, {
    "backgroundOnHover": {
      "alias": "backgroundOnHover";
      "required": false;
    };
    "debounceTime": {
      "alias": "debounceTime";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "fieldset": {
      "alias": "fieldset";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "orientation": {
      "alias": "orientation";
      "required": false;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "requiredValidationMessage": {
      "alias": "requiredValidationMessage";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqChange": "bqChange";
    "bqBlur": "bqBlur";
  }, never, ["*"], false, never>;
}
export declare interface BqRadioGroup extends Components.BqRadioGroup {
  /**
   * Handler to be called when the radio state changes
   */
  bqChange: EventEmitter<BqRadioGroupCustomEvent<{
    value: string;
    target: HTMLBqRadioElement;
  }>>;
  /**
   * Handler to be called when the radio loses focus
   */
  bqBlur: EventEmitter<BqRadioGroupCustomEvent<HTMLBqRadioElement>>;
}
export declare class BqSelect {
  protected z: NgZone;
  protected el: HTMLBqSelectElement;
  /**
   * If true, the Select input will be focused on component render
   */
  set autofocus(_: Components.BqSelect['autofocus']);
  /**
   * The clear button aria label @default 'Clear value'
   */
  set clearButtonLabel(_: Components.BqSelect['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: `bqInput` is emitted synchronously and options are filtered right away. @default 0
   */
  set debounceTime(_: Components.BqSelect['debounceTime']);
  /**
   * If true, the Select panel will not lock the page body scroll when open. @default false
   */
  set disableScrollLock(_: Components.BqSelect['disableScrollLock']);
  /**
   * Indicates whether the Select input is disabled or not.
If `true`, the Select is disabled and cannot be interacted with. @default false
   */
  set disabled(_: Components.BqSelect['disabled']);
  /**
   * If true, the clear button won't be displayed @default false
   */
  set disableClear(_: Components.BqSelect['disableClear']);
  /**
   * If true, the search functionality within the Select panel will be disabled. No typing will be allowed @default false
   */
  set disableSearch(_: Components.BqSelect['disableSearch']);
  /**
   * Represents the distance (gutter or margin) between the Select panel and the input element. @default 8
   */
  set distance(_: Components.BqSelect['distance']);
  /**
   * The ID of the form that the Select input belongs to.
   */
  set form(_: Components.BqSelect['form']);
  /**
   * The native form validation message (mandatory if `required` is set)
   */
  set formValidationMessage(_: Components.BqSelect['formValidationMessage']);
  /**
   * If true, the Select panel will remain open after a selection is made. @default false
   */
  set keepOpenOnSelect(_: Components.BqSelect['keepOpenOnSelect']);
  /**
   * The Select input name.
   */
  set name(_: Components.BqSelect['name']);
  /**
   * The maximum number of tags to display when multiple selection is enabled @default 2
   */
  set maxTagsVisible(_: Components.BqSelect['maxTagsVisible']);
  /**
   * If true, the Select input will allow multiple selections. @default false
   */
  set multiple(_: Components.BqSelect['multiple']);
  /**
   * If true, the Select panel will be visible. @default false
   */
  set open(_: Components.BqSelect['open']);
  /**
   * When set, it will override the height of the Select panel.
   */
  set panelHeight(_: Components.BqSelect['panelHeight']);
  /**
   * The Select input placeholder text value
   */
  set placeholder(_: Components.BqSelect['placeholder']);
  /**
   * Position of the Select panel @default 'bottom'
   */
  set placement(_: Components.BqSelect['placement']);
  /**
   *  @deprecated Use `disableSearch` to allow selection without text filtering.
In a future major release, `readonly` will prevent changing the selected value.
   */
  set readonly(_: Components.BqSelect['readonly']);
  /**
   * Indicates whether or not the Select input is required to be filled out before submitting the form.
   */
  set required(_: Components.BqSelect['required']);
  /**
   * Whether the panel should have the Select same width as the input element @default true
   */
  set sameWidth(_: Components.BqSelect['sameWidth']);
  /**
   * If true, flat options render with checkboxes when multiple selection is enabled. Nested multi-select options always render with checkboxes.
   */
  set enableCheckboxes(_: Components.BqSelect['enableCheckboxes']);
  /**
   * Represents the skidding between the Select panel and the input element. @default 0
   */
  set skidding(_: Components.BqSelect['skidding']);
  /**
   * Defines the strategy to position the Select panel @default 'fixed'
   */
  set strategy(_: Components.BqSelect['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.,@default 'none'
   */
  set validationStatus(_: Components.BqSelect['validationStatus']);
  /**
   * The select input value, it can be used to reset the field to a previous value
   */
  set value(_: Components.BqSelect['value']);
  bqBlur: EventEmitter<BqSelectCustomEvent<HTMLBqSelectElement>>;
  bqClear: EventEmitter<BqSelectCustomEvent<HTMLBqSelectElement>>;
  bqFocus: EventEmitter<BqSelectCustomEvent<HTMLBqSelectElement>>;
  bqSelect: EventEmitter<BqSelectCustomEvent<TSelectChangeDetail>>;
  bqInput: EventEmitter<BqSelectCustomEvent<{
    value: string | number | string[];
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSelect, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSelect, "bq-select", never, {
    "autofocus": {
      "alias": "autofocus";
      "required": false;
    };
    "clearButtonLabel": {
      "alias": "clearButtonLabel";
      "required": false;
    };
    "debounceTime": {
      "alias": "debounceTime";
      "required": false;
    };
    "disableClear": {
      "alias": "disableClear";
      "required": false;
    };
    "disableScrollLock": {
      "alias": "disableScrollLock";
      "required": false;
    };
    "disableSearch": {
      "alias": "disableSearch";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "distance": {
      "alias": "distance";
      "required": false;
    };
    "enableCheckboxes": {
      "alias": "enableCheckboxes";
      "required": false;
    };
    "form": {
      "alias": "form";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "keepOpenOnSelect": {
      "alias": "keepOpenOnSelect";
      "required": false;
    };
    "maxTagsVisible": {
      "alias": "maxTagsVisible";
      "required": false;
    };
    "multiple": {
      "alias": "multiple";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "panelHeight": {
      "alias": "panelHeight";
      "required": false;
    };
    "placeholder": {
      "alias": "placeholder";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "readonly": {
      "alias": "readonly";
      "required": false;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "sameWidth": {
      "alias": "sameWidth";
      "required": false;
    };
    "skidding": {
      "alias": "skidding";
      "required": false;
    };
    "strategy": {
      "alias": "strategy";
      "required": false;
    };
    "validationStatus": {
      "alias": "validationStatus";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqClear": "bqClear";
    "bqFocus": "bqFocus";
    "bqSelect": "bqSelect";
    "bqInput": "bqInput";
  }, never, ["*"], false, never>;
}
export declare interface BqSelect extends Components.BqSelect {
  /**
   * Emitted when focus leaves the entire Select, including its input, options, and controls.
   */
  bqBlur: EventEmitter<BqSelectCustomEvent<HTMLBqSelectElement>>;
  /**
   * Callback handler emitted when the selected value has been cleared
   */
  bqClear: EventEmitter<BqSelectCustomEvent<HTMLBqSelectElement>>;
  /**
   * Emitted when focus enters the Select from outside the component.
   */
  bqFocus: EventEmitter<BqSelectCustomEvent<HTMLBqSelectElement>>;
  /**
   * Callback handler emitted when the selected value has changed. Nested multi-select also includes selected paths in `selectionTree`.
   */
  bqSelect: EventEmitter<BqSelectCustomEvent<TSelectChangeDetail>>;
  /**
   * Callback handler emitted when the Select input changes its value while typing
   */
  bqInput: EventEmitter<BqSelectCustomEvent<{
    value: string | number | string[];
  }>>;
}
export declare class BqSideMenu {
  protected z: NgZone;
  protected el: HTMLBqSideMenuElement;
  /**
   * It sets a predefined appearance of the side menu @default 'default'
   */
  set appearance(_: Components.BqSideMenu['appearance']);
  /**
   * If true, the container will reduce its width @default false
   */
  set collapse(_: Components.BqSideMenu['collapse']);
  /**
   * It sets the size of the navigation menu items @default 'medium'
   */
  set size(_: Components.BqSideMenu['size']);
  bqCollapse: EventEmitter<BqSideMenuCustomEvent<{
    collapse: boolean;
  }>>;
  bqSelect: EventEmitter<BqSideMenuCustomEvent<HTMLBqSideMenuItemElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSideMenu, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSideMenu, "bq-side-menu", never, {
    "appearance": {
      "alias": "appearance";
      "required": false;
    };
    "collapse": {
      "alias": "collapse";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
  }, {
    "bqCollapse": "bqCollapse";
    "bqSelect": "bqSelect";
  }, never, ["*"], false, never>;
}
export declare interface BqSideMenu extends Components.BqSideMenu {
  /**
   * Callback handler to be called when the Side menu changes its width from expanded to collapse and vice versa
   */
  bqCollapse: EventEmitter<BqSideMenuCustomEvent<{
    collapse: boolean;
  }>>;
  /**
   * Callback handler to be called when the active/selected menu item changes
   */
  bqSelect: EventEmitter<BqSideMenuCustomEvent<HTMLBqSideMenuItemElement>>;
}
export declare class BqSideMenuItem {
  protected z: NgZone;
  protected el: HTMLBqSideMenuItemElement;
  /**
   * If true, the menu item will be shown as active/selected. @default false
   */
  set active(_: Components.BqSideMenuItem['active']);
  /**
   * If true, the item label and suffix will be hidden and the `width` will be reduced according to its parent. @default false
   */
  set collapse(_: Components.BqSideMenuItem['collapse']);
  /**
   * If true, the menu item will be disabled (no interaction allowed) @default false
   */
  set disabled(_: Components.BqSideMenuItem['disabled']);
  bqBlur: EventEmitter<BqSideMenuItemCustomEvent<HTMLBqSideMenuItemElement>>;
  bqFocus: EventEmitter<BqSideMenuItemCustomEvent<HTMLBqSideMenuItemElement>>;
  bqClick: EventEmitter<BqSideMenuItemCustomEvent<HTMLBqSideMenuItemElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSideMenuItem, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSideMenuItem, "bq-side-menu-item", never, {
    "active": {
      "alias": "active";
      "required": false;
    };
    "collapse": {
      "alias": "collapse";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqFocus": "bqFocus";
    "bqClick": "bqClick";
  }, never, ["*"], false, never>;
}
export declare interface BqSideMenuItem extends Components.BqSideMenuItem {
  /**
   * Handler to be called when the button loses focus
   */
  bqBlur: EventEmitter<BqSideMenuItemCustomEvent<HTMLBqSideMenuItemElement>>;
  /**
   * Handler to be called when the button is clicked
   */
  bqFocus: EventEmitter<BqSideMenuItemCustomEvent<HTMLBqSideMenuItemElement>>;
  /**
   * Handler to be called when button gets focus
   */
  bqClick: EventEmitter<BqSideMenuItemCustomEvent<HTMLBqSideMenuItemElement>>;
}
export declare class BqSlider {
  protected z: NgZone;
  protected el: HTMLBqSliderElement;
  /**
   * The amount of time, in milliseconds, to wait to trigger the `bqChange` event after each value change.
With `0` (default), the event is emitted synchronously. @default 0
   */
  set debounceTime(_: Components.BqSlider['debounceTime']);
  /**
   * If `true` the slider is disabled. @default false
   */
  set disabled(_: Components.BqSlider['disabled']);
  /**
   * If `true` it will show the value label on a side of the slider track area @default false
   */
  set enableValueIndicator(_: Components.BqSlider['enableValueIndicator']);
  /**
   * A number representing the amount to remain between the minimum and maximum values (only for range type). @default 0
   */
  set gap(_: Components.BqSlider['gap']);
  /**
   * A number representing the max value of the slider. @default 100
   */
  set max(_: Components.BqSlider['max']);
  /**
   * A number representing the min value of the slider. @default 0
   */
  set min(_: Components.BqSlider['min']);
  /**
   * Name of the form control. Submitted with the form as part of a name/value pair
   */
  set name(_: Components.BqSlider['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`. @default 1
   */
  set step(_: Components.BqSlider['step']);
  /**
   * It defines the type of slider to display @default 'single'
   */
  set type(_: Components.BqSlider['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(_: Components.BqSlider['value']);
  /**
   * If `true`, a tooltip will be shown displaying the progress value @default false
   */
  set enableTooltip(_: Components.BqSlider['enableTooltip']);
  /**
   * If `true`, a tooltip will always display the progress value.
It relies on enableTooltip and if enableTooltip is false, tooltipAlwaysVisible cannot be true. @default false
   */
  set tooltipAlwaysVisible(_: Components.BqSlider['tooltipAlwaysVisible']);
  bqChange: EventEmitter<BqSliderCustomEvent<{
    value: Exclude<TSliderValue, string>;
    el: HTMLBqSliderElement;
  }>>;
  bqBlur: EventEmitter<BqSliderCustomEvent<HTMLBqSliderElement>>;
  bqFocus: EventEmitter<BqSliderCustomEvent<HTMLBqSliderElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSlider, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSlider, "bq-slider", never, {
    "debounceTime": {
      "alias": "debounceTime";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "enableTooltip": {
      "alias": "enableTooltip";
      "required": false;
    };
    "enableValueIndicator": {
      "alias": "enableValueIndicator";
      "required": false;
    };
    "gap": {
      "alias": "gap";
      "required": false;
    };
    "max": {
      "alias": "max";
      "required": false;
    };
    "min": {
      "alias": "min";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": false;
    };
    "step": {
      "alias": "step";
      "required": false;
    };
    "tooltipAlwaysVisible": {
      "alias": "tooltipAlwaysVisible";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqChange": "bqChange";
    "bqBlur": "bqBlur";
    "bqFocus": "bqFocus";
  }, never, ["*"], false, never>;
}
export declare interface BqSlider extends Components.BqSlider {
  /**
   * Handler to be called when change the value on range inputs
   */
  bqChange: EventEmitter<BqSliderCustomEvent<{
    value: Exclude<TSliderValue, string>;
    el: HTMLBqSliderElement;
  }>>;
  /**
   * Handler to be called when the slider loses focus
   */
  bqBlur: EventEmitter<BqSliderCustomEvent<HTMLBqSliderElement>>;
  /**
   * Handler to be called when the slider gets focused
   */
  bqFocus: EventEmitter<BqSliderCustomEvent<HTMLBqSliderElement>>;
}
export declare class BqSpinner {
  protected z: NgZone;
  protected el: HTMLBqSpinnerElement;
  /**
   * If `false`, the animation on the icon element will be stopped @default true
   */
  set animation(_: Components.BqSpinner['animation']);
  /**
   * It defines the position of the label text @default 'none'
   */
  set textPosition(_: Components.BqSpinner['textPosition']);
  /**
   * It defines the size of the icon element displayed @default 'medium'
   */
  set size(_: Components.BqSpinner['size']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSpinner, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSpinner, "bq-spinner", never, {
    "animation": {
      "alias": "animation";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "textPosition": {
      "alias": "textPosition";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqSpinner extends Components.BqSpinner {}
export declare class BqStatus {
  protected z: NgZone;
  protected el: HTMLBqStatusElement;
  /**
   * It defines the type of status to display @default 'neutral'
   */
  set type(_: Components.BqStatus['type']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqStatus, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqStatus, "bq-status", never, {
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqStatus extends Components.BqStatus {}
export declare class BqStepItem {
  protected z: NgZone;
  protected el: HTMLBqStepItemElement;
  /**
   * The color of the line that connects the steps. It should be a valid declarative color token. @default 'stroke--primary'
   */
  set dividerColor(_: Components.BqStepItem['dividerColor']);
  /**
   * It defines the orientation of the step item @default 'horizontal'
   */
  set orientation(_: Components.BqStepItem['orientation']);
  /**
   * It defines prefix size @default 'medium'
   */
  set size(_: Components.BqStepItem['size']);
  /**
   * It defines step item appearance based on its status @default 'default'
   */
  set status(_: Components.BqStepItem['status']);
  /**
   * It defines the step item type used
   */
  set type(_: Components.BqStepItem['type']);
  bqClick: EventEmitter<BqStepItemCustomEvent<HTMLBqStepItemElement>>;
  bqFocus: EventEmitter<BqStepItemCustomEvent<HTMLBqStepItemElement>>;
  bqBlur: EventEmitter<BqStepItemCustomEvent<HTMLBqStepItemElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqStepItem, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqStepItem, "bq-step-item", never, {
    "dividerColor": {
      "alias": "dividerColor";
      "required": false;
    };
    "orientation": {
      "alias": "orientation";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "status": {
      "alias": "status";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {
    "bqClick": "bqClick";
    "bqFocus": "bqFocus";
    "bqBlur": "bqBlur";
  }, never, ["*"], false, never>;
}
export declare interface BqStepItem extends Components.BqStepItem {
  /**
   * Callback handler triggered when the step item is clicked
   */
  bqClick: EventEmitter<BqStepItemCustomEvent<HTMLBqStepItemElement>>;
  /**
   * Callback handler triggered when the step item is focused
   */
  bqFocus: EventEmitter<BqStepItemCustomEvent<HTMLBqStepItemElement>>;
  /**
   * Callback handler triggered when the step item loses focus
   */
  bqBlur: EventEmitter<BqStepItemCustomEvent<HTMLBqStepItemElement>>;
}
export declare class BqSteps {
  protected z: NgZone;
  protected el: HTMLBqStepsElement;
  /**
   * The color of the line that connects the steps. It should be a valid declarative color token. @default 'stroke--primary'
   */
  set dividerColor(_: Components.BqSteps['dividerColor']);
  /**
   * The orientation of the steps @default 'horizontal'
   */
  set orientation(_: Components.BqSteps['orientation']);
  /**
   * The size of the steps @default 'medium'
   */
  set size(_: Components.BqSteps['size']);
  /**
   * The type of prefix element to use on the step items
   */
  set type(_: Components.BqSteps['type']);
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSteps, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSteps, "bq-steps", never, {
    "dividerColor": {
      "alias": "dividerColor";
      "required": false;
    };
    "orientation": {
      "alias": "orientation";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {}, never, ["*"], false, never>;
}
export declare interface BqSteps extends Components.BqSteps {}
export declare class BqSwitch {
  protected z: NgZone;
  protected el: HTMLBqSwitchElement;
  /**
   * If true, a background will be displayed on hover @default false
   */
  set backgroundOnHover(_: Components.BqSwitch['backgroundOnHover']);
  /**
   * It indicates whether if the switch is `ON` by default (when the page loads) @default false
   */
  set checked(_: Components.BqSwitch['checked']);
  /**
   * If true, the switch control will be disabled and no interaction will be allowed @default false
   */
  set disabled(_: Components.BqSwitch['disabled']);
  /**
   * The native form validation message
   */
  set formValidationMessage(_: Components.BqSwitch['formValidationMessage']);
  /**
   * If true, the component will take the full width space available on the parent container @default false
   */
  set fullWidth(_: Components.BqSwitch['fullWidth']);
  /**
   * It indicates how to to display the on/off marks inside the control, with icons or none (default) @default 'default'
   */
  set innerLabel(_: Components.BqSwitch['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) @default 'start'
   */
  set justifyContent(_: Components.BqSwitch['justifyContent']);
  /**
   * Name of the form control. Submitted with the form as part of a name/value pair
   */
  set name(_: Components.BqSwitch['name']);
  /**
   * If `true`, it will indicate that the user must switch `ON` the element before the owning form can be submitted @default false
   */
  set required(_: Components.BqSwitch['required']);
  /**
   * If true, the order of the control and the label text will be changed @default false
   */
  set reverseOrder(_: Components.BqSwitch['reverseOrder']);
  /**
   * The input control's value, submitted as a name/value pair with form data.
   */
  set value(_: Components.BqSwitch['value']);
  bqChange: EventEmitter<BqSwitchCustomEvent<{
    checked: boolean;
  }>>;
  bqFocus: EventEmitter<BqSwitchCustomEvent<HTMLBqSwitchElement>>;
  bqBlur: EventEmitter<BqSwitchCustomEvent<HTMLBqSwitchElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqSwitch, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqSwitch, "bq-switch", never, {
    "backgroundOnHover": {
      "alias": "backgroundOnHover";
      "required": false;
    };
    "checked": {
      "alias": "checked";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "fullWidth": {
      "alias": "fullWidth";
      "required": false;
    };
    "innerLabel": {
      "alias": "innerLabel";
      "required": false;
    };
    "justifyContent": {
      "alias": "justifyContent";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "reverseOrder": {
      "alias": "reverseOrder";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqChange": "bqChange";
    "bqFocus": "bqFocus";
    "bqBlur": "bqBlur";
  }, never, ["*"], false, never>;
}
export declare interface BqSwitch extends Components.BqSwitch {
  /**
   * Handler to be called when the switch state changes
   */
  bqChange: EventEmitter<BqSwitchCustomEvent<{
    checked: boolean;
  }>>;
  /**
   * Handler to be called when the switch gets focus
   */
  bqFocus: EventEmitter<BqSwitchCustomEvent<HTMLBqSwitchElement>>;
  /**
   * Handler to be called when the switch loses focus
   */
  bqBlur: EventEmitter<BqSwitchCustomEvent<HTMLBqSwitchElement>>;
}
export declare class BqTab {
  protected z: NgZone;
  protected el: HTMLBqTabElement;
  /**
   * If true tab is active
   */
  set active(_: Components.BqTab['active']);
  /**
   * The tab panel id that the tab controls
   */
  set controls(_: Components.BqTab['controls']);
  /**
   * If true tab is disabled @default false
   */
  set disabled(_: Components.BqTab['disabled']);
  /**
   * The direction that tab should be render @default 'horizontal'
   */
  set orientation(_: Components.BqTab['orientation']);
  /**
   * The placement that tab should be render @default 'start'
   */
  set placement(_: Components.BqTab['placement']);
  /**
   * The size of the tab @default 'medium'
   */
  set size(_: Components.BqTab['size']);
  /**
   * The id of the tab
   */
  set tabId(_: Components.BqTab['tabId']);
  bqClick: EventEmitter<BqTabCustomEvent<HTMLBqTabElement>>;
  bqFocus: EventEmitter<BqTabCustomEvent<HTMLBqTabElement>>;
  bqBlur: EventEmitter<BqTabCustomEvent<HTMLBqTabElement>>;
  bqKeyDown: EventEmitter<BqTabCustomEvent<KeyboardEvent>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqTab, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqTab, "bq-tab", never, {
    "active": {
      "alias": "active";
      "required": false;
    };
    "controls": {
      "alias": "controls";
      "required": true;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "orientation": {
      "alias": "orientation";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "tabId": {
      "alias": "tabId";
      "required": true;
    };
  }, {
    "bqClick": "bqClick";
    "bqFocus": "bqFocus";
    "bqBlur": "bqBlur";
    "bqKeyDown": "bqKeyDown";
  }, never, ["*"], false, never>;
}
export declare interface BqTab extends Components.BqTab {
  /**
   * Handler to be called when the tab state changes
   */
  bqClick: EventEmitter<BqTabCustomEvent<HTMLBqTabElement>>;
  /**
   * Handler to be called when the tab gets focus
   */
  bqFocus: EventEmitter<BqTabCustomEvent<HTMLBqTabElement>>;
  /**
   * Handler to be called when the tab loses focus
   */
  bqBlur: EventEmitter<BqTabCustomEvent<HTMLBqTabElement>>;
  /**
   * Handler to be called when the tab key is pressed
   */
  bqKeyDown: EventEmitter<BqTabCustomEvent<KeyboardEvent>>;
}
export declare class BqTabGroup {
  protected z: NgZone;
  protected el: HTMLBqTabGroupElement;
  /**
   * A number representing the delay value applied to bqChange event handler. With `0` (default), the event is emitted synchronously. @default 0
   */
  set debounceTime(_: Components.BqTabGroup['debounceTime']);
  /**
   * If true, the underline divider below the tabs won't be shown @default false
   */
  set disableDivider(_: Components.BqTabGroup['disableDivider']);
  /**
   * The direction that tab should be render @default 'horizontal'
   */
  set orientation(_: Components.BqTabGroup['orientation']);
  /**
   * The placement that tab should be render @default 'start'
   */
  set placement(_: Components.BqTabGroup['placement']);
  /**
   * The size of the tab @default 'medium'
   */
  set size(_: Components.BqTabGroup['size']);
  /**
   * A string representing the id of the selected tab.
   */
  set value(_: Components.BqTabGroup['value']);
  bqChange: EventEmitter<BqTabGroupCustomEvent<{
    target: HTMLBqTabElement;
    value: string;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqTabGroup, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqTabGroup, "bq-tab-group", never, {
    "debounceTime": {
      "alias": "debounceTime";
      "required": false;
    };
    "disableDivider": {
      "alias": "disableDivider";
      "required": false;
    };
    "orientation": {
      "alias": "orientation";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqChange": "bqChange";
  }, never, ["*"], false, never>;
}
export declare interface BqTabGroup extends Components.BqTabGroup {
  /**
   * Handler to be called when the tab value changes
   */
  bqChange: EventEmitter<BqTabGroupCustomEvent<{
    target: HTMLBqTabElement;
    value: string;
  }>>;
}
export declare class BqTag {
  protected z: NgZone;
  protected el: HTMLBqTagElement;
  /**
   * The corner radius of the Tag (will override size's predefined border)
   */
  set border(_: Components.BqTag['border']);
  /**
   * If true, the Tag can be clickable @default false
   */
  set clickable(_: Components.BqTag['clickable']);
  /**
   * The color style of the Tag
   */
  set color(_: Components.BqTag['color']);
  /**
   * If true, the Tag will be disabled (only if clickable = `true`, no interaction allowed) @default false
   */
  set disabled(_: Components.BqTag['disabled']);
  /**
   * If true, the Tag component will be hidden
   */
  set hidden(_: Components.BqTag['hidden']);
  /**
   * If true, the Tag component can be removed @default false
   */
  set removable(_: Components.BqTag['removable']);
  /**
   * If true, the Tag is selected (only if clickable = `true`) @default false
   */
  set selected(_: Components.BqTag['selected']);
  /**
   * The size of the Tag component @default 'medium'
   */
  set size(_: Components.BqTag['size']);
  /**
   * The variant of Tag to apply on top of the variant @default 'filled'
   */
  set variant(_: Components.BqTag['variant']);
  bqClose: EventEmitter<BqTagCustomEvent<any>>;
  bqOpen: EventEmitter<BqTagCustomEvent<any>>;
  bqBlur: EventEmitter<BqTagCustomEvent<HTMLBqTagElement>>;
  bqClick: EventEmitter<BqTagCustomEvent<HTMLBqTagElement>>;
  bqFocus: EventEmitter<BqTagCustomEvent<HTMLBqTagElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqTag, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqTag, "bq-tag", never, {
    "border": {
      "alias": "border";
      "required": false;
    };
    "clickable": {
      "alias": "clickable";
      "required": false;
    };
    "color": {
      "alias": "color";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "hidden": {
      "alias": "hidden";
      "required": false;
    };
    "removable": {
      "alias": "removable";
      "required": false;
    };
    "selected": {
      "alias": "selected";
      "required": false;
    };
    "size": {
      "alias": "size";
      "required": false;
    };
    "variant": {
      "alias": "variant";
      "required": false;
    };
  }, {
    "bqClose": "bqClose";
    "bqOpen": "bqOpen";
    "bqBlur": "bqBlur";
    "bqClick": "bqClick";
    "bqFocus": "bqFocus";
  }, never, ["*"], false, never>;
}
export declare interface BqTag extends Components.BqTag {
  /**
   * Callback handler to be called when the tag is close/hidden
   */
  bqClose: EventEmitter<BqTagCustomEvent<any>>;
  /**
   * Callback handler to be called when the tag is not open/shown
   */
  bqOpen: EventEmitter<BqTagCustomEvent<any>>;
  /**
   * Handler to be called when tag loses focus
   */
  bqBlur: EventEmitter<BqTagCustomEvent<HTMLBqTagElement>>;
  /**
   * Handler to be called when tag is clicked
   */
  bqClick: EventEmitter<BqTagCustomEvent<HTMLBqTagElement>>;
  /**
   * Handler to be called when tag is focused
   */
  bqFocus: EventEmitter<BqTagCustomEvent<HTMLBqTagElement>>;
}
export declare class BqTextarea {
  protected z: NgZone;
  protected el: HTMLBqTextareaElement;
  /**
   * 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,@default 'off'
   */
  set autocapitalize(_: Components.BqTextarea['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,@default 'off'
   */
  set autocomplete(_: Components.BqTextarea['autocomplete']);
  /**
   * If true, the textarea will be focused on component render @default false
   */
  set autofocus(_: Components.BqTextarea['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. @default false
   */
  set autoGrow(_: Components.BqTextarea['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: `bqInput` is emitted synchronously on every input. @default 0
   */
  set debounceTime(_: Components.BqTextarea['debounceTime']);
  /**
   * If `true`, the user cannot interact with the textarea. @default false
   */
  set disabled(_: Components.BqTextarea['disabled']);
  /**
   * If `true`, it will block the user's ability to resize the textarea. @default false
   */
  set disableResize(_: Components.BqTextarea['disableResize']);
  /**
   * The ID of the form that the textarea field belongs to.
   */
  set form(_: Components.BqTextarea['form']);
  /**
   * The native form validation message
   */
  set formValidationMessage(_: Components.BqTextarea['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(_: Components.BqTextarea['maxlength']);
  /**
   * The name of the textarea element.
   */
  set name(_: Components.BqTextarea['name']);
  /**
   * The placeholder text to show when there is no value.
   */
  set placeholder(_: Components.BqTextarea['placeholder']);
  /**
   * If true, the textarea field cannot be modified. @default false
   */
  set readonly(_: Components.BqTextarea['readonly']);
  /**
   * Indicates whether or not the textarea field is required to be filled out before submitting the form. @default false
   */
  set required(_: Components.BqTextarea['required']);
  /**
   * The number of visible text lines for the control. It must be a positive integer. @default 5
   */
  set rows(_: Components.BqTextarea['rows']);
  /**
   * If true, the textarea content may be checked for spelling errors. @default false
   */
  set spellcheck(_: Components.BqTextarea['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.,@default 'none'
   */
  set validationStatus(_: Components.BqTextarea['validationStatus']);
  /**
   * The value of the textarea. It can be used to reset the textarea to a previous value.
   */
  set value(_: Components.BqTextarea['value']);
  /**
   * Specifies how the text in a text area is to be wrapped when submitted in a form @default 'soft'
   */
  set wrap(_: Components.BqTextarea['wrap']);
  bqBlur: EventEmitter<BqTextareaCustomEvent<HTMLBqTextareaElement>>;
  bqChange: EventEmitter<BqTextareaCustomEvent<{
    value: string;
    el: HTMLBqTextareaElement;
  }>>;
  bqClear: EventEmitter<BqTextareaCustomEvent<HTMLBqTextareaElement>>;
  bqFocus: EventEmitter<BqTextareaCustomEvent<HTMLBqTextareaElement>>;
  bqInput: EventEmitter<BqTextareaCustomEvent<{
    value: string;
    el: HTMLBqTextareaElement;
  }>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqTextarea, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqTextarea, "bq-textarea", never, {
    "autoGrow": {
      "alias": "autoGrow";
      "required": false;
    };
    "autocapitalize": {
      "alias": "autocapitalize";
      "required": false;
    };
    "autocomplete": {
      "alias": "autocomplete";
      "required": false;
    };
    "autofocus": {
      "alias": "autofocus";
      "required": false;
    };
    "debounceTime": {
      "alias": "debounceTime";
      "required": false;
    };
    "disableResize": {
      "alias": "disableResize";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "form": {
      "alias": "form";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "maxlength": {
      "alias": "maxlength";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "placeholder": {
      "alias": "placeholder";
      "required": true;
    };
    "readonly": {
      "alias": "readonly";
      "required": false;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "rows": {
      "alias": "rows";
      "required": false;
    };
    "spellcheck": {
      "alias": "spellcheck";
      "required": false;
    };
    "validationStatus": {
      "alias": "validationStatus";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
    "wrap": {
      "alias": "wrap";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqChange": "bqChange";
    "bqClear": "bqClear";
    "bqFocus": "bqFocus";
    "bqInput": "bqInput";
  }, never, ["*"], false, never>;
}
export declare interface BqTextarea extends Components.BqTextarea {
  /**
   * Callback handler emitted when the textarea loses focus
   */
  bqBlur: EventEmitter<BqTextareaCustomEvent<HTMLBqTextareaElement>>;
  /**
     * Callback handler emitted when the textarea value has changed and the textarea loses focus.
  This handler is called whenever the user finishes typing or pasting text into the textarea field and then clicks outside of the textarea field.
     */
  bqChange: EventEmitter<BqTextareaCustomEvent<{
    value: string;
    el: HTMLBqTextareaElement;
  }>>;
  /**
     *  @deprecated `bq-textarea` never emits `bqClear`. It will be removed in the next major release.
  Listen to `bqInput` or `bqChange` and check for an empty value instead.
     */
  bqClear: EventEmitter<BqTextareaCustomEvent<HTMLBqTextareaElement>>;
  /**
   * Callback handler emitted when the textarea has received focus
   */
  bqFocus: EventEmitter<BqTextareaCustomEvent<HTMLBqTextareaElement>>;
  /**
     * Callback handler emitted when the textarea value changes.
  This handler is called whenever the user types or pastes text into the textarea field.
     */
  bqInput: EventEmitter<BqTextareaCustomEvent<{
    value: string;
    el: HTMLBqTextareaElement;
  }>>;
}
export declare class BqTimePicker {
  protected z: NgZone;
  protected el: HTMLBqTimePickerElement;
  /**
   * If `true`, the Time picker field will be focused on component render. @default false
   */
  set autofocus(_: Components.BqTimePicker['autofocus']);
  /**
   * If `true`, the clear button won't be displayed. @default false
   */
  set disableClear(_: Components.BqTimePicker['disableClear']);
  /**
   * If `true`, the panel "Now" button won't be displayed. @default false
   */
  set disableNow(_: Components.BqTimePicker['disableNow']);
  /**
   * Indicates whether the Time picker is disabled or not. @default false
   */
  set disabled(_: Components.BqTimePicker['disabled']);
  /**
   * Distance (gutter) between the Time picker panel and the field. @default 8
   */
  set distance(_: Components.BqTimePicker['distance']);
  /**
   * The ID of the form the field belongs to.
   */
  set form(_: Components.BqTimePicker['form']);
  /**
   * Native form validation message.
   */
  set formValidationMessage(_: Components.BqTimePicker['formValidationMessage']);
  /**
   * The clock used by the field and the panel: 24-hour (`"24"`) or 12-hour with an AM/PM period (`"12"`).
It doesn't depend on the `locale`. @default '24'
   */
  set hourFormat(_: Components.BqTimePicker['hourFormat']);
  /**
   * Step between selectable hours. @default 1
   */
  set hourStep(_: Components.BqTimePicker['hourStep']);
  /**
   * Text of the column headers, AM/PM labels, buttons and accessible names, as an object or a JSON string.
Missing keys fall back to the `locale` names (`hour`, `minute`, `second`, `am`, `pm`),
`am/pm` (`period`), or English text: `Now`, `Clear`, `OK`, `Open time picker` and `Choose time`.
   */
  set labels(_: Components.BqTimePicker['labels']);
  /**
   * Locale used for the field layout, separators, column headers and day period labels. The clock is set by `hour-format`. @default 'en-GB'
   */
  set locale(_: Components.BqTimePicker['locale']);
  /**
   * Latest selectable time, in 24-hour format (`HH:mm` or `HH:mm:ss`).
Ignored, together with `min`, when it is earlier than `min`.
   */
  set max(_: Components.BqTimePicker['max']);
  /**
   * Earliest selectable time, in 24-hour format (`HH:mm` or `HH:mm:ss`).
Ignored, together with `max`, when it is later than `max`.
   */
  set min(_: Components.BqTimePicker['min']);
  /**
   * Step between selectable minutes. @default 1
   */
  set minuteStep(_: Components.BqTimePicker['minuteStep']);
  /**
   * The Time picker name.
   */
  set name(_: Components.BqTimePicker['name']);
  /**
   * If `true`, the panel is visible. @default false
   */
  set open(_: Components.BqTimePicker['open']);
  /**
   * Overrides the height of the Time picker panel. @default 'auto'
   */
  set panelHeight(_: Components.BqTimePicker['panelHeight']);
  /**
   * Position of the Time picker panel. @default 'bottom-end'
   */
  set placement(_: Components.BqTimePicker['placement']);
  /**
   * The smallest unit edited and submitted.
- `hour`   → `HH:00`
- `minute` → `HH:mm` (default)
- `second` → `HH:mm:ss` @default 'minute'
   */
  set precision(_: Components.BqTimePicker['precision']);
  /**
   * If `true`, the value can be read and submitted but not changed. @default false
   */
  set readonly(_: Components.BqTimePicker['readonly']);
  /**
   * If `true`, picks made in the panel (including "Now") are a draft until confirmed
with the OK button or Enter. The field keeps showing the committed value until then.
Escape or an outside click discards the draft. @default false
   */
  set requireConfirm(_: Components.BqTimePicker['requireConfirm']);
  /**
   * Whether a value must be entered before submitting the form. @default false
   */
  set required(_: Components.BqTimePicker['required']);
  /**
   * Step between selectable seconds. @default 1
   */
  set secondStep(_: Components.BqTimePicker['secondStep']);
  /**
   * Skidding between the panel and the field. @default 0
   */
  set skidding(_: Components.BqTimePicker['skidding']);
  /**
   * Positioning strategy for the panel. @default 'fixed'
   */
  set strategy(_: Components.BqTimePicker['strategy']);
  /**
   * Validation state applied to the field. @default 'none'
   */
  set validationStatus(_: Components.BqTimePicker['validationStatus']);
  /**
   * The selected time, in 24-hour format: `HH:mm` (`HH:00` at hour precision) or `HH:mm:ss` at second precision.
   */
  set value(_: Components.BqTimePicker['value']);
  bqBlur: EventEmitter<BqTimePickerCustomEvent<HTMLBqTimePickerElement>>;
  bqChange: EventEmitter<BqTimePickerCustomEvent<{
    value: string | undefined;
    el: HTMLElement;
  }>>;
  bqClear: EventEmitter<BqTimePickerCustomEvent<HTMLBqTimePickerElement>>;
  bqFocus: EventEmitter<BqTimePickerCustomEvent<HTMLBqTimePickerElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqTimePicker, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqTimePicker, "bq-time-picker", never, {
    "autofocus": {
      "alias": "autofocus";
      "required": false;
    };
    "disableClear": {
      "alias": "disableClear";
      "required": false;
    };
    "disableNow": {
      "alias": "disableNow";
      "required": false;
    };
    "disabled": {
      "alias": "disabled";
      "required": false;
    };
    "distance": {
      "alias": "distance";
      "required": false;
    };
    "form": {
      "alias": "form";
      "required": false;
    };
    "formValidationMessage": {
      "alias": "formValidationMessage";
      "required": false;
    };
    "hourFormat": {
      "alias": "hourFormat";
      "required": false;
    };
    "hourStep": {
      "alias": "hourStep";
      "required": false;
    };
    "labels": {
      "alias": "labels";
      "required": false;
    };
    "locale": {
      "alias": "locale";
      "required": false;
    };
    "max": {
      "alias": "max";
      "required": false;
    };
    "min": {
      "alias": "min";
      "required": false;
    };
    "minuteStep": {
      "alias": "minuteStep";
      "required": false;
    };
    "name": {
      "alias": "name";
      "required": true;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "panelHeight": {
      "alias": "panelHeight";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "precision": {
      "alias": "precision";
      "required": false;
    };
    "readonly": {
      "alias": "readonly";
      "required": false;
    };
    "requireConfirm": {
      "alias": "requireConfirm";
      "required": false;
    };
    "required": {
      "alias": "required";
      "required": false;
    };
    "secondStep": {
      "alias": "secondStep";
      "required": false;
    };
    "skidding": {
      "alias": "skidding";
      "required": false;
    };
    "strategy": {
      "alias": "strategy";
      "required": false;
    };
    "validationStatus": {
      "alias": "validationStatus";
      "required": false;
    };
    "value": {
      "alias": "value";
      "required": false;
    };
  }, {
    "bqBlur": "bqBlur";
    "bqChange": "bqChange";
    "bqClear": "bqClear";
    "bqFocus": "bqFocus";
  }, never, ["*"], false, never>;
}
export declare interface BqTimePicker extends Components.BqTimePicker {
  /**
   * Callback handler emitted when focus leaves the Time picker. Moving focus between the field and the panel doesn't emit it.
   */
  bqBlur: EventEmitter<BqTimePickerCustomEvent<HTMLBqTimePickerElement>>;
  /**
   * Callback handler emitted when the value is committed or cleared.
   */
  bqChange: EventEmitter<BqTimePickerCustomEvent<{
    value: string | undefined;
    el: HTMLElement;
  }>>;
  /**
   * Callback handler emitted when the value is cleared.
   */
  bqClear: EventEmitter<BqTimePickerCustomEvent<HTMLBqTimePickerElement>>;
  /**
   * Callback handler emitted when focus enters the Time picker. Moving focus between the field and the panel doesn't emit it.
   */
  bqFocus: EventEmitter<BqTimePickerCustomEvent<HTMLBqTimePickerElement>>;
}
export declare class BqToast {
  protected z: NgZone;
  protected el: HTMLBqToastElement;
  /**
   * The corder radius of the toast component @default 's'
   */
  set border(_: Components.BqToast['border']);
  /**
   * Type of toast @default 'info'
   */
  set type(_: Components.BqToast['type']);
  /**
   * Placement of toast @default 'bottom-center'
   */
  set placement(_: Components.BqToast['placement']);
  /**
   * If true will hide toast icon @default false
   */
  set hideIcon(_: Components.BqToast['hideIcon']);
  /**
   * If true, the toast will be shown
   */
  set open(_: Components.BqToast['open']);
  /**
   * The length of time, in milliseconds, after which the toast will close itself @default 3000
   */
  set time(_: Components.BqToast['time']);
  bqHide: EventEmitter<BqToastCustomEvent<HTMLBqToastElement>>;
  bqShow: EventEmitter<BqToastCustomEvent<HTMLBqToastElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqToast, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqToast, "bq-toast", never, {
    "border": {
      "alias": "border";
      "required": false;
    };
    "hideIcon": {
      "alias": "hideIcon";
      "required": false;
    };
    "open": {
      "alias": "open";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "time": {
      "alias": "time";
      "required": false;
    };
    "type": {
      "alias": "type";
      "required": false;
    };
  }, {
    "bqHide": "bqHide";
    "bqShow": "bqShow";
  }, never, ["*"], false, never>;
}
export declare interface BqToast extends Components.BqToast {
  /**
   * Callback handler to be called when the notification is hidden
   */
  bqHide: EventEmitter<BqToastCustomEvent<HTMLBqToastElement>>;
  /**
   * Callback handler to be called when the notification is shown
   */
  bqShow: EventEmitter<BqToastCustomEvent<HTMLBqToastElement>>;
}
export declare class BqTooltip {
  protected z: NgZone;
  protected el: HTMLBqTooltipElement;
  /**
   * If true, the tooltip will always be visible @default false
   */
  set alwaysVisible(_: Components.BqTooltip['alwaysVisible']);
  /**
   * Distance between trigger element and tooltip @default 10
   */
  set distance(_: Components.BqTooltip['distance']);
  /**
   * If true, the arrow on the tooltip content won't be shown @default false
   */
  set hideArrow(_: Components.BqTooltip['hideArrow']);
  /**
   *  @default 'top'
   */
  set placement(_: Components.BqTooltip['placement']);
  /**
   * Whether the tooltip should have the same width as the trigger element
(applicable only for content shorter than the trigger element) @default false
   */
  set sameWidth(_: Components.BqTooltip['sameWidth']);
  /**
   * Set the action when the tooltip should be displayed, on hover (default) or click @default 'hover'
   */
  set displayOn(_: Components.BqTooltip['displayOn']);
  /**
   * Indicates whether or not the tooltip is visible when the component is first rendered,
and when interacting with the trigger @default false
   */
  set visible(_: Components.BqTooltip['visible']);
  bqClick: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  bqFocusIn: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  bqFocusOut: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  bqHoverIn: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  bqHoverOut: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
  static ɵfac: i0.ɵɵFactoryDeclaration<BqTooltip, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<BqTooltip, "bq-tooltip", never, {
    "alwaysVisible": {
      "alias": "alwaysVisible";
      "required": false;
    };
    "displayOn": {
      "alias": "displayOn";
      "required": false;
    };
    "distance": {
      "alias": "distance";
      "required": false;
    };
    "hideArrow": {
      "alias": "hideArrow";
      "required": false;
    };
    "placement": {
      "alias": "placement";
      "required": false;
    };
    "sameWidth": {
      "alias": "sameWidth";
      "required": false;
    };
    "visible": {
      "alias": "visible";
      "required": false;
    };
  }, {
    "bqClick": "bqClick";
    "bqFocusIn": "bqFocusIn";
    "bqFocusOut": "bqFocusOut";
    "bqHoverIn": "bqHoverIn";
    "bqHoverOut": "bqHoverOut";
  }, never, ["*"], false, never>;
}
export declare interface BqTooltip extends Components.BqTooltip {
  /**
   * Emitted when the tooltip trigger is clicked
   */
  bqClick: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  /**
   * Emitted when the tooltip trigger is focused in
   */
  bqFocusIn: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  /**
   * Emitted when the tooltip trigger is focused out
   */
  bqFocusOut: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  /**
   * Emitted when the tooltip trigger is hovered in
   */
  bqHoverIn: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
  /**
   * Emitted when the tooltip trigger is hovered out
   */
  bqHoverOut: EventEmitter<BqTooltipCustomEvent<HTMLBqTooltipElement>>;
}
export declare class BeeQModule {
  static forRoot(): ModuleWithProviders<BeeQModule>;
  static ɵfac: i0.ɵɵFactoryDeclaration<BeeQModule, never>;
  static ɵmod: i0.ɵɵNgModuleDeclaration<BeeQModule, [typeof BqAccordion, typeof BqAccordionGroup, typeof BqAlert, typeof BqAvatar, typeof BqBadge, typeof BqBreadcrumb, typeof BqBreadcrumbItem, typeof BqButton, typeof BqCard, typeof BqCheckbox, typeof BqDatePicker, typeof BqDialog, typeof BqDivider, typeof BqDrawer, typeof BqDropdown, typeof BqEmptyState, typeof BqIcon, typeof BqInput, typeof BqNotification, typeof BqOption, typeof BqOptionGroup, typeof BqOptionList, typeof BqPageTitle, typeof BqPanel, typeof BqProgress, typeof BqRadio, typeof BqRadioGroup, typeof BqSelect, typeof BqSideMenu, typeof BqSideMenuItem, typeof BqSlider, typeof BqSpinner, typeof BqStatus, typeof BqStepItem, typeof BqSteps, typeof BqSwitch, typeof BqTab, typeof BqTabGroup, typeof BqTag, typeof BqTextarea, typeof BqTimePicker, typeof BqToast, typeof BqTooltip, typeof BooleanValueAccessor, typeof NumericValueAccessor, typeof RadioValueAccessor, typeof SelectValueAccessor, typeof TextValueAccessor], [typeof i7.CommonModule], [typeof BqAccordion, typeof BqAccordionGroup, typeof BqAlert, typeof BqAvatar, typeof BqBadge, typeof BqBreadcrumb, typeof BqBreadcrumbItem, typeof BqButton, typeof BqCard, typeof BqCheckbox, typeof BqDatePicker, typeof BqDialog, typeof BqDivider, typeof BqDrawer, typeof BqDropdown, typeof BqEmptyState, typeof BqIcon, typeof BqInput, typeof BqNotification, typeof BqOption, typeof BqOptionGroup, typeof BqOptionList, typeof BqPageTitle, typeof BqPanel, typeof BqProgress, typeof BqRadio, typeof BqRadioGroup, typeof BqSelect, typeof BqSideMenu, typeof BqSideMenuItem, typeof BqSlider, typeof BqSpinner, typeof BqStatus, typeof BqStepItem, typeof BqSteps, typeof BqSwitch, typeof BqTab, typeof BqTabGroup, typeof BqTag, typeof BqTextarea, typeof BqTimePicker, typeof BqToast, typeof BqTooltip, typeof BooleanValueAccessor, typeof NumericValueAccessor, typeof RadioValueAccessor, typeof SelectValueAccessor, typeof TextValueAccessor]>;
  static ɵinj: i0.ɵɵInjectorDeclaration<BeeQModule>;
}