@db-ux/ngx-core-components 3.1.20 → 4.0.1-0-540218c

package/index.d.ts

@@ -1,83 +1,3241 @@
-export * from './components/accordion';
-export * from './components/accordion-item';
-export * from './components/accordion-item/model';
-export * from './components/accordion/model';
-export * from './components/badge';
-export * from './components/badge/model';
-export * from './components/brand';
-export * from './components/brand/model';
-export * from './components/button';
-export * from './components/button/model';
-export * from './components/card';
-export * from './components/card/model';
-export * from './components/checkbox';
-export * from './components/checkbox/model';
-export * from './components/custom-select';
-export * from './components/custom-select-dropdown';
-export * from './components/custom-select-dropdown/model';
-export * from './components/custom-select-form-field';
-export * from './components/custom-select-form-field/model';
-export * from './components/custom-select-list';
-export * from './components/custom-select-list-item';
-export * from './components/custom-select-list-item/model';
-export * from './components/custom-select-list/model';
-export * from './components/custom-select/model';
-export * from './components/divider';
-export * from './components/divider/model';
-export * from './components/drawer';
-export * from './components/drawer/model';
-export * from './components/header';
-export * from './components/header/SecondaryAction.directive';
-export * from './components/header/MetaNavigation.directive';
-export * from './components/header/Navigation.directive';
-export * from './components/header/model';
-export * from './components/icon';
-export * from './components/icon/model';
-export * from './components/infotext';
-export * from './components/infotext/model';
-export * from './components/input';
-export * from './components/input/model';
-export * from './components/link';
-export * from './components/link/model';
-export * from './components/navigation';
-export * from './components/navigation-item';
-export * from './components/navigation-item/NavigationContent.directive';
-export * from './components/navigation-item/model';
-export * from './components/navigation/model';
-export * from './components/notification';
-export * from './components/notification/model';
-export * from './components/page';
-export * from './components/page/model';
-export * from './components/popover';
-export * from './components/popover/model';
-export * from './components/radio';
-export * from './components/radio/model';
-export * from './components/section';
-export * from './components/section/model';
-export * from './components/select';
-export * from './components/select/model';
-export * from './components/stack';
-export * from './components/stack/model';
-export * from './components/switch';
-export * from './components/switch/model';
-export * from './components/tab-item';
-export * from './components/tab-item/model';
-export * from './components/tab-list';
-export * from './components/tab-list/model';
-export * from './components/tab-panel';
-export * from './components/tab-panel/model';
-export * from './components/tabs';
-export * from './components/tabs/model';
-export * from './components/tag';
-export * from './components/tag/model';
-export * from './components/textarea';
-export * from './components/textarea/model';
-export * from './components/tooltip';
-export * from './components/tooltip/model';
-export * from './shared/constants';
-export * from './shared/model';
-export * from './utils/document-click-listener';
-export * from './utils/document-scroll-listener';
-export * from './utils/floating-components';
-export * from './utils/index';
-export * from './utils/navigation';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, InputSignal, ElementRef, ModelSignal, Renderer2, OnDestroy } from '@angular/core';
+import { IconTypes } from '@db-ux/core-foundations';
+import { ControlValueAccessor } from '@angular/forms';
+
+type GlobalProps = {
+    /**
+     * default slot
+     */
+    children?: any;
+    /**
+     * React specific for adding className to the component.
+     */
+    className?: string;
+    /**
+     * Workaround for TypeScript using class for all components.
+     */
+    class?: string | any;
+    /**
+     * [ID](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id) of the component, generated automatically for some components as a fallback if unset.
+     */
+    id?: string;
+    /**
+     * Before using please check for the [accessibility concerns](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autofocus#accessibility_concerns)
+     */
+    autofocus?: boolean | string;
+};
+type GlobalState = {
+    _id?: string;
+};
+declare const SemanticList: readonly ["adaptive", "neutral", "critical", "informational", "warning", "successful"];
+type SemanticType = (typeof SemanticList)[number];
+type SemanticProps = {
+    /**
+     * The semantic defines the default variants for most components.
+     */
+    semantic?: SemanticType;
+};
+type IconProps = {
+    /**
+     * Define an icon by its identifier (like e.g. _user_, compare to [Icons](https://design-system.deutschebahn.com/core-web/review/main/foundations/icons/overview)) to get displayed in front of the elements content.
+     */
+    icon?: IconTypes;
+};
+type ShowIconProps = {
+    /**
+     * Enables or disables the visibility of the icon. The default value depends on the component.
+     * For many components this property is optional to reflect Figma properties.
+     */
+    showIcon?: boolean | string;
+};
+type ShowIconLeadingProps = {
+    /**
+     * Enables or disables the visibility of the leading icon.
+     * For many components this property is optional to reflect Figma properties.
+     */
+    showIconLeading?: boolean | string;
+};
+type ShowIconTrailingProps = {
+    /**
+     * Enables or disables the visibility of the trailing icon.
+     * For many components this property is optional to reflect Figma properties.
+     */
+    showIconTrailing?: boolean | string;
+};
+type IconLeadingProps = {
+    /**
+     * Define an icon by its identifier (like e.g. _user_, compare to [Icons](https://design-system.deutschebahn.com/core-web/review/main/foundations/icons/overview)) to get displayed in front of the elements content.
+     */
+    iconLeading?: IconTypes;
+};
+type IconTrailingProps = {
+    /**
+     * Define an icon by its identifier (like e.g. _user_, compare to [Icons](https://design-system.deutschebahn.com/core-web/review/main/foundations/icons/overview)) to get displayed in front of the elements content.
+     */
+    iconTrailing?: IconTypes;
+};
+declare const SpacingList: readonly ["medium", "small", "large", "none"];
+type SpacingType = (typeof SpacingList)[number];
+type SpacingProps = {
+    /**
+     * The spacing attribute changes the padding of the component.
+     */
+    spacing?: SpacingType | string;
+};
+declare const MarginList: readonly ["medium", "small", "large", "none"];
+type MarginType = (typeof MarginList)[number];
+type MarginProps = {
+    /**
+     * The margin attribute changes the margin of the component.
+     */
+    margin?: MarginType;
+};
+declare const PlacementHorizontalList: readonly ["left", "right", "left-start", "left-end", "right-start", "right-end"];
+type PlacementHorizontalType = (typeof PlacementHorizontalList)[number];
+declare const PlacementVerticalList: readonly ["top", "bottom", "top-start", "top-end", "bottom-start", "bottom-end"];
+type PlacementVerticalType = (typeof PlacementVerticalList)[number];
+declare const PlacementList: readonly ["left", "right", "left-start", "left-end", "right-start", "right-end", "top", "bottom", "top-start", "top-end", "bottom-start", "bottom-end"];
+type PlacementType = (typeof PlacementList)[number];
+type PlacementProps = {
+    /**
+     * The `placement` attributes values change the position to absolute and adds a transform based on the placement.
+     */
+    placement?: PlacementType;
+};
+type NavigationBehaviorState = {
+    handleNavigationItemClick: (event: any) => void;
+};
+type GapProps = {
+    /**
+     * If the absolute element should have a gap between the parent element.
+     */
+    gap?: boolean | string;
+};
+declare const GapSpacingList: readonly ["none", "3x-large", "2x-large", "x-large", "large", "medium", "small", "x-small", "2x-small", "3x-small"];
+type GapSpacingType = (typeof GapSpacingList)[number];
+type GapSpacingProps = {
+    /**
+     * Set the gap/spacing between elements
+     */
+    gap?: GapSpacingType;
+};
+type OverflowProps = {
+    /**
+     * The overflow attribute sets a max-width and longer text will be dotted.
+     */
+    overflow?: boolean | string;
+};
+type WrapProps = {
+    /**
+     * Determines whether the text should wrap when its parent container is too small, preventing overflow.
+     */
+    wrap?: boolean | string;
+};
+declare const OrientationList: readonly ["horizontal", "vertical"];
+type OrientationType = (typeof OrientationList)[number];
+type OrientationProps = {
+    /**
+     * Change the orientation. Defaults to horizontal.
+     */
+    orientation?: OrientationType;
+};
+declare const WidthList: readonly ["full", "auto"];
+type WidthType = (typeof WidthList)[number];
+type WidthProps = {
+    /**
+     * Width of the component. Auto width based on children size, full width based on parent elements width.
+     */
+    width?: WidthType | string;
+};
+declare const MaxWidthList: readonly ["full", "medium", "large", "small"];
+type MaxWidthType = (typeof MaxWidthList)[number];
+type ContainerWidthProps = {
+    /**
+     * Set max width for the component
+     */
+    width?: MaxWidthType;
+};
+declare const PopoverDelayList: readonly ["none", "slow", "fast"];
+type PopoverDelayType = (typeof PopoverDelayList)[number];
+declare const PopoverWidthList: readonly ["auto", "fixed"];
+type PopoverWidthType = (typeof PopoverWidthList)[number];
+type PopoverProps = {
+    /**
+     * Add a delay before showing the tooltip
+     */
+    delay?: PopoverDelayType;
+    /**
+     * Disable animation
+     */
+    animation?: boolean | string;
+    /**
+     * Use fixed with for default max-width
+     */
+    width?: PopoverWidthType;
+};
+type NameProps = {
+    /**
+     * The name attribute gives the name of the element to group it.
+     */
+    name?: string;
+};
+type NameState = {
+    _name?: string;
+    handleNameAttribute: () => void;
+};
+type ContentSlotProps = {
+    /**
+     * Default slot which is used to pass in additional content.
+     */
+    content?: any;
+};
+declare const SizeList: readonly ["small", "medium"];
+type SizeType = (typeof SizeList)[number];
+type SizeProps = {
+    /**
+     * The size attribute changes the font-size and other related sizes of the component.
+     */
+    size?: SizeType;
+};
+declare const EmphasisList: readonly ["weak", "strong"];
+type EmphasisType = (typeof EmphasisList)[number];
+type EmphasisProps = {
+    /**
+     * The emphasis attribute divides in between a weak or strong importance.
+     */
+    emphasis?: EmphasisType;
+};
+declare const ValidationList: readonly ["invalid", "valid", "no-validation"];
+type ValidationType = (typeof ValidationList)[number];
+/**
+ * Properties to control the required state and its visual annotation for input components.
+ */
+type RequiredProps = {
+    /**
+     * When the required attribute specified, the user will be required to fill the form element before submitting the form.
+     * The form element will be marked semantically as required and by default also visually with an asterisk '*' next to the label (unless the property `showRequiredAsterisk` is also set with the value `false`).
+     */
+    required?: boolean | string;
+    /**
+     * This attribute allows to specify whether a form field which is marked as required will show a visual indicator (an asterisk '*').
+     * It allows to prevent adding the visual indicator but still keep the field semantically required by setting its value to `false`.
+     * By default, its value is `true`, so the asterisk is shown when `required` is set.
+     */
+    showRequiredAsterisk?: boolean | string;
+};
+type ShowLabelProps = {
+    /**
+     * Enables/disables the visibility of the label
+     */
+    showLabel?: boolean | string;
+};
+type ValueProps = {
+    /**
+     * The value property is to receive results from the native form element.
+     */
+    value?: any;
+};
+type BaseFormProps = {
+    /**
+     * The disabled attribute can be set to keep a user from clicking on the form element.
+     */
+    disabled?: boolean | string;
+    /**
+     * The label attribute specifies the caption of the form element.
+     */
+    label?: string;
+    /**
+     * The name attribute gives the name of the form control, as used in form submission and in the form element's elements object.
+     */
+    name?: string;
+};
+type CustomFormProps = {
+    /**
+     * Overwrites auto handling for aria-describedby.
+     */
+    ariaDescribedBy?: string;
+    /**
+     * 	Associates the control with a form element
+     */
+    form?: string;
+    /**
+     * Marks an input element as invalid (red) / valid (green) / no-validation (grey). Overwrites the :user-valid selector.
+     */
+    validation?: ValidationType;
+};
+type FormProps = CustomFormProps & BaseFormProps & RequiredProps & ShowLabelProps & ValueProps;
+declare const FieldSizingList: readonly ["fixed", "content"];
+type FieldSizingType = (typeof FieldSizingList)[number];
+type FormTextProps = {
+    /**
+     * Maximum length (number of characters) of value
+     */
+    maxLength?: number | string;
+    /**
+     * Minimum length (number of characters) of value
+     */
+    minLength?: number | string;
+    /**
+     * Maximum length (number of characters) of value
+     */
+    maxlength?: number | string;
+    /**
+     * Minimum length (number of characters) of value
+     */
+    minlength?: number | string;
+    /**
+     * The disabled attribute can be set to keep a user from edit on the form element
+     */
+    readOnly?: boolean | string;
+    /**
+     * The disabled attribute can be set to keep a user from edit on the form element
+     */
+    readonly?: boolean | string;
+    /**
+     * Adds shrinkwrap for input and textarea: https://developer.mozilla.org/en-US/docs/Web/CSS/field-sizing
+     * Note: Only supported in Chromium browsers so far
+     */
+    fieldSizing?: FieldSizingType;
+};
+type FormSizeProps = {
+    /**
+     * Size of the control
+     */
+    size?: number;
+};
+type FormCheckProps = {
+    /**
+     * Define the radio or checkbox elements checked state
+     */
+    checked?: boolean | string;
+};
+declare const LabelVariantList: readonly ["above", "floating"];
+type LabelVariantType = (typeof LabelVariantList)[number];
+declare const LabelVariantHorizontalList: readonly ["leading", "trailing"];
+type LabelVariantHorizontalType = (typeof LabelVariantHorizontalList)[number];
+declare const AutoCompleteList: readonly ["off", "on", "name", "honorific-prefix", "given-name", "additional-name", "family-name", "honorific-suffix", "nickname", "email", "username", "new-password", "current-password", "one-time-code", "organization-title", "organization", "street-address", "shipping", "billing", "address-line1", "address-line2", "address-line3", "address-level4", "address-level3", "address-level2", "address-level1", "country", "country-name", "postal-code", "cc-name", "cc-given-name", "cc-additional-name", "cc-family-name", "cc-number", "cc-exp", "cc-exp-month", "cc-exp-year", "cc-csc", "cc-type", "transaction-currency", "transaction-amount", "language", "bday", "bday-day", "bday-month", "bday-year", "sex", "tel", "tel-country-code", "tel-national", "tel-area-code", "tel-local", "tel-extension", "impp", "url", "photo", "webauthn"];
+type AutoCompleteType = (typeof AutoCompleteList)[number];
+type FormMessageProps = {
+    /**
+     * Change the variant of the label to float or hidden
+     */
+    variant?: LabelVariantType;
+    /**
+     * Text that appears in the form control when it has no value set
+     */
+    placeholder?: string;
+    /**
+     * Optional helper message for form components
+     */
+    message?: string;
+    /**
+     * Helper message for valid form components
+     */
+    validMessage?: string;
+    /**
+     * Helper message for invalid form components
+     */
+    invalidMessage?: string;
+    /**
+     * Set/overwrite icon for helper message for form components
+     */
+    messageIcon?: IconTypes;
+    /**
+     * See https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete
+     */
+    autocomplete?: string | AutoCompleteType;
+    /**
+     * Enables or disables the visibility of the message.
+     */
+    showMessage?: boolean | string;
+};
+type FromValidState = {
+    hasValidState: () => boolean;
+    handleValidation: () => void;
+    _invalidMessage?: string;
+};
+type FormState = {
+    _messageId?: string;
+    _validMessageId?: string;
+    _invalidMessageId?: string;
+    _descByIds?: string;
+    _value?: string;
+    _invalidMessage?: string;
+    /**
+     * https://www.davidmacd.com/blog/test-aria-describedby-errormessage-aria-live.html
+     * Currently VoiceOver isn't supporting changes from aria-describedby.
+     * This is an internal Fallback
+     */
+    _voiceOverFallback?: string;
+};
+type InitializedState = {
+    initialized: boolean;
+};
+declare const LinkTargetList: readonly ["_self", "_blank", "_parent", "_top"];
+type LinkTargetType = (typeof LinkTargetList)[number];
+declare const LinkReferrerPolicyList: readonly ["no-referrer", "no-referrer-when-downgrade", "origin", "origin-when-cross-origin", "same-origin", "strict-origin", "strict-origin-when-cross-origin", "unsafe-url"];
+type LinkReferrerPolicyType = (typeof LinkReferrerPolicyList)[number];
+type LinkProps = {
+    /**
+     * Disables the link.
+     */
+    disabled?: boolean | string;
+    /**
+     * The [URL that the hyperlink points to](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#href).
+     */
+    href?: string;
+    /**
+     * Hints for the human [language of the linked page or document](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#hreflang).
+     */
+    hreflang?: string;
+    /**
+     * Where to open the linked URL, as the name for a [browsing context](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#target).
+     */
+    target?: LinkTargetType;
+    /**
+     * The relationship of the linked URL as space-separated link types.
+     */
+    rel?: string;
+    /**
+     * Sets aria role based on [`aria-role`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles).
+     */
+    role?: string;
+    /**
+     * How much of the referrer to send when following the link.
+     */
+    referrerpolicy?: LinkReferrerPolicyType;
+};
+type TextProps = {
+    /**
+     * Alternative for default slot/children.
+     */
+    text?: string;
+};
+type GeneralEvent<T> = Event;
+type GeneralKeyboardEvent<T> = KeyboardEvent;
+type ClickEvent<T> = MouseEvent;
+type ClickEventProps<T> = {
+    /**
+     * React specific onClick to pass to forward ref.
+     */
+    onClick?: (event: ClickEvent<T>) => void;
+};
+type ClickEventState<T> = {
+    handleClick: (event: ClickEvent<T> | any) => void;
+};
+type ToggleEventProps = {
+    toggle?: (open: boolean) => void;
+    onToggle?: (open: boolean) => void;
+};
+type ToggleEventState<T> = {
+    handleToggle: (event?: ClickEvent<T> | any) => void;
+};
+type CloseEventProps<T> = {
+    /**
+     * Function to handle button click (close).
+     */
+    onClose?: (event?: T) => void;
+    /**
+     * Function to handle button click (close).
+     */
+    close?: (event?: T) => void;
+};
+type CloseEventState<T> = {
+    handleClose: (event?: T | void, forceClose?: boolean) => void;
+};
+declare const AlignmentList: readonly ["start", "center"];
+type AlignmentType = (typeof AlignmentList)[number];
+type AlignmentProps = {
+    /**
+     * Define the content alignment in full width
+     */
+    alignment?: AlignmentType | string;
+};
+type ActiveProps = {
+    /**
+     * If the tab is checked/active.
+     */
+    active?: boolean | string;
+};
+type InputEvent<T> = Event;
+type InputEventProps<T> = {
+    input?: (event: InputEvent<T>) => void;
+    onInput?: (event: InputEvent<T>) => void;
+};
+type InputEventState<T> = {
+    handleInput: (event: InputEvent<T> | any) => void;
+};
+type ChangeEvent<T> = Event;
+type ChangeEventProps<T> = {
+    change?: (event: ChangeEvent<T>) => void;
+    onChange?: (event: ChangeEvent<T>) => void;
+};
+type ChangeEventState<T> = {
+    handleChange: (event: ChangeEvent<T> | any) => void;
+};
+type InteractionEvent<T> = FocusEvent;
+type FocusEventProps<T> = {
+    blur?: (event: InteractionEvent<T>) => void;
+    onBlur?: (event: InteractionEvent<T>) => void;
+    focus?: (event: InteractionEvent<T>) => void;
+    onFocus?: (event: InteractionEvent<T>) => void;
+};
+type FocusEventState<T> = {
+    handleBlur: (event: InteractionEvent<T> | any) => void;
+    handleFocus: (event: InteractionEvent<T> | any) => void;
+};
+type InnerCloseButtonProps = {
+    /**
+     * The closeButtonId attribute changes the id inside the close button.
+     */
+    closeButtonId?: string;
+    /**
+     * The closeButtonText attribute changes the text inside the close button.
+     */
+    closeButtonText?: string;
+};
+type NavigationBackButtonProps = {
+    /**
+     * The backButtonId attribute changes the id inside the back button.
+     */
+    backButtonId?: string;
+    /**
+     * The backButtonText attribute changes the text inside the back button.
+     */
+    backButtonText?: string;
+};
+type AriaControlsProps = {
+    /**
+     * Pass `aria-controls` to inner element
+     */
+    controls?: string;
+};
+type ValueLabelType = {
+    value: string;
+    label?: string;
+};
+type DocumentScrollState = {
+    _documentScrollListenerCallbackId?: string;
+    handleDocumentScroll: (event: any, parent?: HTMLElement) => void;
+    _observer?: IntersectionObserver;
+};
+type PopoverState = {
+    handleEscape: (event: any) => void;
+    handleAutoPlacement: (parent?: HTMLElement) => void;
+    handleEnter: (parent?: HTMLElement) => void;
+    handleLeave: (event?: any) => void;
+} & DocumentScrollState;
+
+declare const uuid: () => string;
+declare const addAttributeToChildren: (element: Element, attribute: {
+    key: string;
+    value: string;
+}) => void;
+type ClassNameArg = string | {
+    [key: string]: boolean | undefined;
+} | undefined;
+declare const cls: (...args: ClassNameArg[]) => string;
+declare const isArrayOfStrings: (value: unknown) => value is string[];
+declare const hasVoiceOver: () => boolean;
+/**
+ * Determines if the current browser is Safari running on an iOS device.
+ *
+ * This function checks the user agent string to verify both iOS platform
+ * (iPad, iPhone, or iPod) and Safari browser, excluding other browsers
+ * such as Chrome, Firefox, Opera, and Edge on iOS.
+ *
+ * @returns {boolean} `true` if the browser is Safari on iOS, otherwise `false`.
+ */
+declare const isIOSSafari: () => boolean;
+declare const delay: (fn: () => void, ms: number) => Promise<unknown>;
+/**
+ * Some frameworks like stencil would not add "true" as value for a prop
+ * if it is used in a framework like angular e.g.: [disabled]="myDisabledProp"
+ * @param originBool Some boolean to convert to string
+ */
+declare const getBooleanAsString: (originBool?: boolean | string) => any;
+declare const getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+declare const getNumber: (originNumber?: number | string, alternativeNumber?: number | string) => number | undefined;
+/**
+ * Retrieves the input value based on the provided value and input type.
+ *
+ * If the input type is "number" or "range", the value is processed as a number.
+ * Otherwise, the value is returned as-is.
+ *
+ * @param value - The input value, which can be a number, string, or undefined.
+ * @param inputType - The type of the input, such as "number", "range", or other string types.
+ * @returns The processed input value as a string, number, or undefined.
+ */
+declare const getInputValue: (value?: number | string, inputType?: string) => string | number | undefined;
+declare const getHideProp: (show?: boolean | string) => any;
+declare const stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+declare const getSearchInput: (element: HTMLElement) => HTMLInputElement | null;
+declare const getOptionKey: (option: {
+    id?: string;
+    value?: string | number | string[] | undefined;
+}, prefix: string) => string;
+declare const isKeyboardEvent: <T>(event?: ClickEvent<T> | GeneralKeyboardEvent<T>) => event is GeneralKeyboardEvent<T>;
+
+type DBAccordionItemDefaultProps = {
+    /**
+     * Initial state for the accordion item
+     */
+    defaultOpen?: boolean;
+    /**
+     * The disabled attribute can be set to keep a user from clicking on the element.
+     */
+    disabled?: boolean | string;
+    /**
+     * Title of the accordion-item as slot
+     */
+    headline?: any;
+    /**
+     * Title of the accordion-item as plain text
+     */
+    headlinePlain?: string;
+} & TextProps;
+type DBAccordionItemProps = DBAccordionItemDefaultProps & GlobalProps & ToggleEventProps & NameProps;
+type DBAccordionItemDefaultState = {
+    _open?: boolean;
+};
+type DBAccordionItemState = DBAccordionItemDefaultState & GlobalState & ToggleEventState<HTMLElement> & InitializedState & NameState;
+
+declare const AccordionVariantList: readonly ["divider", "card"];
+type AccordionVariantType = (typeof AccordionVariantList)[number];
+declare const AccordionBehaviorList: readonly ["multiple", "single"];
+type AccordionBehaviorType = (typeof AccordionBehaviorList)[number];
+type DBAccordionDefaultProps = {
+    /**
+     * To allow multiple items open at the same time or only 1 item
+     */
+    behavior?: AccordionBehaviorType;
+    /**
+     * The index of items which should be open when loading the accordion
+     */
+    initOpenIndex?: number[];
+    /**
+     * Alternative to pass in a simple representation of accordion items
+     */
+    items?: DBAccordionItemDefaultProps[] | string;
+    /**
+     * Set details name for exclusive accordions, see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details#name
+     */
+    name?: string;
+    /**
+     * Informs about the changes in the internal state, which item is open
+     */
+    onChange?: (openAccordionItemIds: string[]) => void;
+    /**
+     * Defines the display of the accordion and the items:
+     * "divider": with a dividing line between the items
+     * "card": w/o dividing line, but items are shown in the card variant
+     */
+    variant?: AccordionVariantType;
+};
+type DBAccordionProps = DBAccordionDefaultProps & GlobalProps;
+type DBAccordionDefaultState = {
+    _initOpenIndexDone: boolean;
+    _name?: string;
+    convertItems: () => DBAccordionItemDefaultProps[];
+};
+type DBAccordionState = DBAccordionDefaultState & GlobalState & InitializedState;
+
+declare class DBAccordion implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBAccordionProps["id"]>;
+    name: InputSignal<DBAccordionProps["name"]>;
+    behavior: InputSignal<DBAccordionProps["behavior"]>;
+    initOpenIndex: InputSignal<DBAccordionProps["initOpenIndex"]>;
+    items: InputSignal<DBAccordionProps["items"]>;
+    className: InputSignal<DBAccordionProps["className"]>;
+    variant: InputSignal<DBAccordionProps["variant"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _name: _angular_core.WritableSignal<string | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    _initOpenIndexDone: _angular_core.WritableSignal<boolean>;
+    convertItems(): any;
+    trackByItem0(index: number, item: any): string;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBAccordion, "db-accordion", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; "initOpenIndex": { "alias": "initOpenIndex"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DBAccordionItem implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    id: InputSignal<DBAccordionItemProps["id"]>;
+    defaultOpen: InputSignal<DBAccordionItemProps["defaultOpen"]>;
+    name: InputSignal<DBAccordionItemProps["name"]>;
+    className: InputSignal<DBAccordionItemProps["className"]>;
+    disabled: InputSignal<DBAccordionItemProps["disabled"]>;
+    headlinePlain: InputSignal<DBAccordionItemProps["headlinePlain"]>;
+    text: InputSignal<DBAccordionItemProps["text"]>;
+    toggle: _angular_core.OutputEmitterRef<boolean | void>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _open: _angular_core.WritableSignal<boolean | undefined>;
+    _name: _angular_core.WritableSignal<string | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    handleNameAttribute(): void;
+    handleToggle(event: ClickEvent<HTMLElement> | any): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBAccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBAccordionItem, "db-accordion-item", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "headlinePlain": { "alias": "headlinePlain"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "toggle": "toggle"; }, never, ["[headline]", "*"], true, never>;
+}
+
+declare const BadgePlacementList: readonly ["inline", "corner-top-left", "corner-top-right", "corner-center-left", "corner-center-right", "corner-bottom-left", "corner-bottom-right"];
+type BadgePlacementType = (typeof BadgePlacementList)[number];
+type DBBadgeDefaultProps = {
+    /**
+     * The `placement` attributes `corner-*` values change the position to absolute and adds a transform based on the placement.
+     */
+    placement?: BadgePlacementType;
+    /**
+     * Describes the badge for a11y if you use placement attribute with `corner-*`
+     */
+    label?: string;
+};
+type DBBadgeProps = DBBadgeDefaultProps & GlobalProps & SemanticProps & SizeProps & EmphasisProps & TextProps;
+type DBBadgeDefaultState = {};
+type DBBadgeState = DBBadgeDefaultState & GlobalState & InitializedState;
+
+declare class DBBadge implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly DEFAULT_LABEL: string;
+    placement: InputSignal<DBBadgeProps["placement"]>;
+    id: InputSignal<DBBadgeProps["id"]>;
+    className: InputSignal<DBBadgeProps["className"]>;
+    semantic: InputSignal<DBBadgeProps["semantic"]>;
+    size: InputSignal<DBBadgeProps["size"]>;
+    emphasis: InputSignal<DBBadgeProps["emphasis"]>;
+    label: InputSignal<DBBadgeProps["label"]>;
+    text: InputSignal<DBBadgeProps["text"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBBadge, "db-badge", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "semantic": { "alias": "semantic"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBBrandDefaultProps = {
+    /**
+     * @deprecated: Disable the default logo svg to pass in a custom `img`
+     */
+    hideLogo?: boolean;
+};
+type DBBrandProps = DBBrandDefaultProps & GlobalProps & IconProps & ShowIconProps & TextProps;
+type DBBrandDefaultState = {};
+type DBBrandState = DBBrandDefaultState & GlobalState;
+
+declare class DBBrand implements AfterViewInit {
+    protected readonly DEFAULT_ICON: string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    hideLogo: InputSignal<DBBrandProps["hideLogo"]>;
+    icon: InputSignal<DBBrandProps["icon"]>;
+    showIcon: InputSignal<DBBrandProps["showIcon"]>;
+    id: InputSignal<DBBrandProps["id"]>;
+    className: InputSignal<DBBrandProps["className"]>;
+    text: InputSignal<DBBrandProps["text"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBBrand, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBBrand, "db-brand", never, { "hideLogo": { "alias": "hideLogo"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const ButtonVariantList: readonly ["outlined", "brand", "filled", "ghost"];
+type ButtonVariantType = (typeof ButtonVariantList)[number];
+declare const ButtonTypeList: readonly ["button", "reset", "submit"];
+type ButtonTypeType = (typeof ButtonTypeList)[number];
+type DBButtonDefaultProps = {
+    /**
+     * The disabled attribute can be set to [keep a user from clicking on the button](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#disabled).
+     */
+    disabled?: boolean | string;
+    /**
+     * 	Associates the control with a form element
+     */
+    form?: string;
+    /**
+     * The name attribute specifies a [name attributes value](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#name) for the button.
+     */
+    name?: string;
+    /**
+     * Define the text next to the icon specified via the icon Property to get hidden.
+     */
+    noText?: boolean | string;
+    /**
+     * The type attribute specifies the [type of button](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#type).
+     */
+    type?: ButtonTypeType;
+    /**
+     * The value attribute specifies an initial [value for the button](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#value).
+     */
+    value?: string;
+    /**
+     * Variant of the button. Use only 1 primary button on a page as CTA otherwise use one of the adaptive buttons.
+     */
+    variant?: ButtonVariantType | string;
+};
+type DBButtonProps = DBButtonDefaultProps & GlobalProps & ClickEventProps<HTMLButtonElement> & IconProps & WidthProps & SizeProps & ShowIconProps & TextProps & ShowIconLeadingProps & ShowIconTrailingProps & IconLeadingProps & IconTrailingProps;
+type DBButtonDefaultState = {
+    getButtonType: () => ButtonTypeType;
+};
+type DBButtonState = DBButtonDefaultState & GlobalState;
+
+declare class DBButton implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    type: InputSignal<DBButtonProps["type"]>;
+    id: InputSignal<DBButtonProps["id"]>;
+    className: InputSignal<DBButtonProps["className"]>;
+    disabled: InputSignal<DBButtonProps["disabled"]>;
+    iconLeading: InputSignal<DBButtonProps["iconLeading"]>;
+    icon: InputSignal<DBButtonProps["icon"]>;
+    showIconLeading: InputSignal<DBButtonProps["showIconLeading"]>;
+    showIcon: InputSignal<DBButtonProps["showIcon"]>;
+    iconTrailing: InputSignal<DBButtonProps["iconTrailing"]>;
+    showIconTrailing: InputSignal<DBButtonProps["showIconTrailing"]>;
+    size: InputSignal<DBButtonProps["size"]>;
+    width: InputSignal<DBButtonProps["width"]>;
+    variant: InputSignal<DBButtonProps["variant"]>;
+    noText: InputSignal<DBButtonProps["noText"]>;
+    name: InputSignal<DBButtonProps["name"]>;
+    form: InputSignal<DBButtonProps["form"]>;
+    value: InputSignal<DBButtonProps["value"]>;
+    text: InputSignal<DBButtonProps["text"]>;
+    click: _angular_core.OutputEmitterRef<void | MouseEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    getButtonType(): "button" | "reset" | "submit" | undefined;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBButton, "db-button", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "iconLeading": { "alias": "iconLeading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIconLeading": { "alias": "showIconLeading"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "iconTrailing": { "alias": "iconTrailing"; "required": false; "isSignal": true; }; "showIconTrailing": { "alias": "showIconTrailing"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "noText": { "alias": "noText"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "click": "click"; }, never, ["*"], true, never>;
+}
+
+declare const CardBehaviorList: readonly ["static", "interactive"];
+type CardBehaviorType = (typeof CardBehaviorList)[number];
+declare const CardElevationLevelList: readonly ["1", "2", "3"];
+type CardElevationLevelType = (typeof CardElevationLevelList)[number];
+type DBCardDefaultProps = {
+    /**
+     * Makes the card interactive
+     */
+    behavior?: CardBehaviorType;
+    /**
+     * Changes the elevation of the card which is equal to `basic-background-level`
+     */
+    elevationLevel?: CardElevationLevelType;
+};
+type DBCardProps = DBCardDefaultProps & GlobalProps & ClickEventProps<HTMLElement> & SpacingProps;
+type DBCardDefaultState = {};
+type DBCardState = DBCardDefaultState & GlobalState & ClickEventState<HTMLElement>;
+
+declare class DBCard implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBCardProps["id"]>;
+    className: InputSignal<DBCardProps["className"]>;
+    behavior: InputSignal<DBCardProps["behavior"]>;
+    elevationLevel: InputSignal<DBCardProps["elevationLevel"]>;
+    spacing: InputSignal<DBCardProps["spacing"]>;
+    click: _angular_core.OutputEmitterRef<void | MouseEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    handleClick(event: ClickEvent<HTMLElement>): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCard, "db-card", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; "elevationLevel": { "alias": "elevationLevel"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; }, { "click": "click"; }, never, ["*"], true, never>;
+}
+
+type DBCheckboxDefaultProps = {
+    /**
+     * Define an [indeterminate](https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement#indeterminate) state of a checkbox
+     */
+    indeterminate?: boolean | string;
+};
+type DBCheckboxProps = DBCheckboxDefaultProps & GlobalProps & ChangeEventProps<HTMLInputElement> & FocusEventProps<HTMLInputElement> & FormProps & FormCheckProps & FormMessageProps & SizeProps;
+type DBCheckboxDefaultState = {};
+type DBCheckboxState = DBCheckboxDefaultState & GlobalState & ChangeEventState<HTMLInputElement> & FocusEventState<HTMLInputElement> & FormState & InitializedState & FromValidState;
+
+declare class DBCheckbox implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly DEFAULT_VALID_MESSAGE: string;
+    id: InputSignal<DBCheckboxProps["id"]>;
+    invalidMessage: InputSignal<DBCheckboxProps["invalidMessage"]>;
+    message: InputSignal<DBCheckboxProps["message"]>;
+    showMessage: InputSignal<DBCheckboxProps["showMessage"]>;
+    indeterminate: InputSignal<DBCheckboxProps["indeterminate"]>;
+    checked: ModelSignal<DBCheckboxProps["checked"]>;
+    validMessage: InputSignal<DBCheckboxProps["validMessage"]>;
+    validation: InputSignal<DBCheckboxProps["validation"]>;
+    required: InputSignal<DBCheckboxProps["required"]>;
+    className: InputSignal<DBCheckboxProps["className"]>;
+    size: InputSignal<DBCheckboxProps["size"]>;
+    showRequiredAsterisk: InputSignal<DBCheckboxProps["showRequiredAsterisk"]>;
+    showLabel: InputSignal<DBCheckboxProps["showLabel"]>;
+    name: InputSignal<DBCheckboxProps["name"]>;
+    disabled: ModelSignal<DBCheckboxProps["disabled"]>;
+    value: InputSignal<DBCheckboxProps["value"]>;
+    ariaDescribedBy: InputSignal<DBCheckboxProps["ariaDescribedBy"]>;
+    label: InputSignal<DBCheckboxProps["label"]>;
+    messageIcon: InputSignal<DBCheckboxProps["messageIcon"]>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    blur: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    focus: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _messageId: _angular_core.WritableSignal<string | undefined>;
+    _validMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessage: _angular_core.WritableSignal<string | undefined>;
+    _descByIds: _angular_core.WritableSignal<string | undefined>;
+    _voiceOverFallback: _angular_core.WritableSignal<string | undefined>;
+    hasValidState(): boolean;
+    handleValidation(): void;
+    handleChange(event: ChangeEvent<HTMLInputElement>): void;
+    handleBlur(event: InteractionEvent<HTMLInputElement> | any): void;
+    handleFocus(event: InteractionEvent<HTMLInputElement> | any): void;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCheckbox, "db-checkbox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "validMessage": { "alias": "validMessage"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "messageIcon": { "alias": "messageIcon"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "disabled": "disabledChange"; "change": "change"; "blur": "blur"; "focus": "focus"; }, never, ["*"], true, never>;
+}
+
+declare const CustomSelectDropdownWidthList: readonly ["fixed", "auto", "full"];
+type CustomSelectDropdownWidthType = (typeof CustomSelectDropdownWidthList)[number];
+type DBCustomSelectDropdownDefaultProps = {
+    /**
+     * Changes the behavior of the dropdown with.
+     * Default: fixed 328px
+     * Full: Based on the size of the form-field
+     * Auto: Based on the size of the largest list item
+     */
+    width?: CustomSelectDropdownWidthType | string;
+};
+type DBCustomSelectDropdownProps = DBCustomSelectDropdownDefaultProps & GlobalProps;
+type DBCustomSelectDropdownDefaultState = {};
+type DBCustomSelectDropdownState = DBCustomSelectDropdownDefaultState & GlobalState;
+
+type DBCustomSelectFormFieldDefaultProps = {};
+type DBCustomSelectFormFieldProps = DBCustomSelectFormFieldDefaultProps & GlobalProps;
+type DBCustomSelectFormFieldDefaultState = {};
+type DBCustomSelectFormFieldState = DBCustomSelectFormFieldDefaultState & GlobalState;
+
+declare const CustomSelectListItemTypeList: readonly ["checkbox", "radio"];
+type CustomSelectListItemTypeType = (typeof CustomSelectListItemTypeList)[number];
+type DBCustomSelectListItemExtraProps = {
+    /**
+     * If the item is a group title (only text)
+     */
+    isGroupTitle?: boolean;
+    /**
+     * Show a divider on the bottom of the list item for visual grouping (don't use it on every item)
+     */
+    showDivider?: boolean;
+} & IconProps & ShowIconProps;
+type DBCustomSelectListItemDefaultProps = {
+    /**
+     * Set the title of a group of items - disables radio/checkbox behavior
+     */
+    groupTitle?: string;
+    /**
+     * Change the behavior of the item single(radio) or multiple(checkbox)
+     */
+    type?: CustomSelectListItemTypeType;
+};
+type DBCustomSelectListItemProps = DBCustomSelectListItemDefaultProps & GlobalProps & BaseFormProps & ValueProps & FormCheckProps & ChangeEventProps<HTMLInputElement> & DBCustomSelectListItemExtraProps;
+type DBCustomSelectListItemDefaultState = {
+    getIconTrailing: () => string | undefined;
+    hasDivider?: boolean;
+};
+type DBCustomSelectListItemState = DBCustomSelectListItemDefaultState & ChangeEventState<HTMLInputElement> & GlobalState;
+
+type CustomSelectOptionType = {
+    /**
+     * Disables this option
+     */
+    disabled?: boolean;
+    /**
+     * Identifier for option
+     */
+    id?: string;
+    /**
+     * If the value is different from the label you want to show to the user.
+     */
+    label?: string;
+    /**
+     * The value for the option
+     */
+    value?: string;
+} & DBCustomSelectListItemExtraProps;
+declare const SelectedTypeList: readonly ["amount", "text", "tag"];
+type SelectedTypeType = (typeof SelectedTypeList)[number];
+type DBCustomSelectEvents = {
+    /**
+     * Optional: if select-type="amount" when amount changes
+     * @param amount The amount of selected checkboxes
+     */
+    onAmountChange?: (amount: number) => void;
+    /**
+     * Optional: if select-type="amount" when amount changes
+     * @param amount The amount of selected checkboxes
+     */
+    amountChange?: (amount: number) => void;
+    /**
+     * Triggers after some option was clicked in dropdown
+     * @param values the changed values
+     */
+    onOptionSelected?: (values: string[]) => void;
+    /**
+     * Triggers after some option was clicked in dropdown
+     * @param values the changed values
+     */
+    optionSelected?: (values: string[]) => void;
+    /**
+     * Informs the user when dropdown was toggled.
+     */
+    onDropdownToggle?: (event: GeneralEvent<HTMLDetailsElement>) => void;
+    /**
+     * Informs the user when dropdown was toggled.
+     */
+    dropdownToggle?: (event: GeneralEvent<HTMLDetailsElement>) => void;
+    /**
+     * Informs the user when a search was performed.
+     */
+    onSearch?: (event: InputEvent<HTMLInputElement>) => void;
+    /**
+     * Informs the user when a search was performed.
+     */
+    search?: (event: InputEvent<HTMLInputElement>) => void;
+};
+type DBCustomSelectDefaultProps = {
+    /**
+     * Optional: if select-type="amount" change the shown text
+     */
+    amountText?: string;
+    /**
+     * Overwrite the default aria-label (props.label) for the custom-select-list
+     */
+    listLabel?: string;
+    /**
+     * Label for the clear selection button
+     */
+    clearSelectionText?: string;
+    /**
+     * Changes the behavior of the dropdown with.
+     * Default: fixed 328px
+     * Auto: Based on the size of the form-field
+     */
+    dropdownWidth?: CustomSelectDropdownWidthType | string;
+    /**
+     * Width of the component. Auto width based on children size, full width based on parent elements width.
+     */
+    formFieldWidth?: WidthType | string;
+    /**
+     * Dropdown - hint if data has to be loaded
+     */
+    loadingText?: string;
+    /**
+     * Change the button text for mobile close
+     */
+    mobileCloseButtonText?: string;
+    /**
+     * Enables CustomSelect
+     */
+    multiple?: boolean | string;
+    /**
+     * Dropdown - hint if there are no options
+     */
+    noResultsText?: string;
+    /**
+     * Programmatically open the dropdown. May differ if you don't use onDropdownToggle.
+     */
+    open?: boolean;
+    /**
+     * You should pass in the options as an array.
+     */
+    options?: CustomSelectOptionType[];
+    /**
+     * The `placement` attributes values change the position to absolute and adds a transform based on the placement.
+     */
+    placement?: PlacementVerticalType;
+    /**
+     * Optional: if you use selectedType=tag and options, you need to set the removeTagsTexts for screen reader users
+     */
+    removeTagsTexts?: string[];
+    /**
+     * Optional: Change the filter function for the search input
+     */
+    searchFilter?: (option: CustomSelectOptionType, filterText: string) => boolean;
+    /**
+     * Search label
+     */
+    searchLabel?: string;
+    /**
+     * Search placeholder
+     */
+    searchPlaceholder?: string;
+    /**
+     * Optional: Prefill the value of the search input
+     */
+    searchValue?: string;
+    /**
+     * Select all checkbox label
+     */
+    selectAllLabel?: string;
+    /**
+     * Optional: If you want to show a custom label for the selected values.
+     * You need to define the empty state as well based on selected options.
+     */
+    selectedLabels?: string;
+    /**
+     * Change the selected type for values shown in multi select
+     */
+    selectedType?: SelectedTypeType;
+    /**
+     * Show clear selection button (default:true). Hide it if you have very small inputs e.g. in tables.
+     */
+    showClearSelection?: boolean;
+    /**
+     * Dropdown - enable loading infotext and spinner
+     */
+    showLoading?: boolean;
+    /**
+     * Dropdown - enable no options infotext
+     */
+    showNoResults?: boolean;
+    /**
+     * Forces search in header.
+     */
+    showSearch?: boolean;
+    /**
+     * Forces select all checkbox (only for multiple).
+     */
+    showSelectAll?: boolean;
+    /**
+     * Optional: If you want to show a custom label based on the selected options.
+     */
+    transformSelectedLabels?: (selectedOptions?: CustomSelectOptionType[]) => string;
+    /**
+     * Initial value for multi select
+     */
+    values?: string[];
+};
+type DBCustomSelectProps = GlobalProps & CustomFormProps & BaseFormProps & RequiredProps & FormMessageProps & DBCustomSelectDefaultProps & DBCustomSelectEvents & DBCustomSelectFormFieldDefaultProps & IconProps & ShowIconProps & ShowLabelProps;
+type DBCustomSelectDefaultState = {
+    _validity?: ValidationType;
+    _values?: string[];
+    _options?: CustomSelectOptionType[];
+    _selectedOptions?: CustomSelectOptionType[];
+    _hasNoOptions: boolean;
+    _selectId?: string;
+    _labelId?: string;
+    _summaryId?: string;
+    _placeholderId?: string;
+    _selectedLabels?: string;
+    _selectedLabelsId?: string;
+    _infoTextId?: string;
+    _internalChangeTimestamp: number;
+    _documentClickListenerCallbackId?: string;
+    _searchValue?: string;
+    _userInteraction?: boolean;
+    getNativeSelectValue: () => string;
+    getOptionLabel: (option: CustomSelectOptionType) => string;
+    getOptionChecked: (value?: string) => boolean;
+    getTagRemoveLabel: (option: CustomSelectOptionType) => string;
+    selectAllEnabled: boolean;
+    searchEnabled: boolean;
+    amountOptions: number;
+    setDescById: (descId?: string) => void;
+    handleTagRemove: (option: CustomSelectOptionType, event?: ClickEvent<HTMLButtonElement> | void) => void;
+    handleSummaryFocus: () => void;
+    handleSelect: (value?: string) => void;
+    handleSelectAll: (event: any) => void;
+    handleClearAll: (event: any) => void;
+    handleDropdownToggle: (event: any) => void;
+    handleDocumentClose: (event: any) => void;
+    handleOpenByKeyboardFocus: () => void;
+    handleFocusFirstDropdownCheckbox: (activeElement?: Element) => void;
+    handleKeyboardPress: (event: any) => void;
+    handleArrowDownUp: (event: any) => void;
+    handleSearch: (event: any) => void;
+    handleOptionSelected: (_values: string[]) => void;
+    getSelectAllLabel: () => string;
+    selectAllChecked: boolean;
+    selectAllIndeterminate: boolean;
+    handleAutoPlacement: () => void;
+};
+type DBCustomSelectState = DBCustomSelectDefaultState & GlobalState & FormState & FromValidState & CloseEventState<InteractionEvent<HTMLDetailsElement>> & DocumentScrollState;
+
+declare class DBCustomSelect implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly DEFAULT_LABEL: string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly getOptionKey: (option: {
+        id?: string;
+        value?: string | number | string[] | undefined;
+    }, prefix: string) => string;
+    protected readonly DEFAULT_MESSAGE: string;
+    protected readonly DEFAULT_CLOSE_BUTTON: string;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly DEFAULT_VALID_MESSAGE: string;
+    id: InputSignal<DBCustomSelectProps["id"]>;
+    invalidMessage: InputSignal<DBCustomSelectProps["invalidMessage"]>;
+    message: InputSignal<DBCustomSelectProps["message"]>;
+    showMessage: InputSignal<DBCustomSelectProps["showMessage"]>;
+    ariaDescribedBy: InputSignal<DBCustomSelectProps["ariaDescribedBy"]>;
+    showNoResults: InputSignal<DBCustomSelectProps["showNoResults"]>;
+    showLoading: InputSignal<DBCustomSelectProps["showLoading"]>;
+    multiple: InputSignal<DBCustomSelectProps["multiple"]>;
+    showSelectAll: InputSignal<DBCustomSelectProps["showSelectAll"]>;
+    showSearch: InputSignal<DBCustomSelectProps["showSearch"]>;
+    values: ModelSignal<DBCustomSelectProps["values"]>;
+    validation: InputSignal<DBCustomSelectProps["validation"]>;
+    options: InputSignal<DBCustomSelectProps["options"]>;
+    searchValue: InputSignal<DBCustomSelectProps["searchValue"]>;
+    selectedLabels: InputSignal<DBCustomSelectProps["selectedLabels"]>;
+    transformSelectedLabels: InputSignal<DBCustomSelectProps["transformSelectedLabels"]>;
+    selectedType: InputSignal<DBCustomSelectProps["selectedType"]>;
+    amountText: InputSignal<DBCustomSelectProps["amountText"]>;
+    validMessage: InputSignal<DBCustomSelectProps["validMessage"]>;
+    required: InputSignal<DBCustomSelectProps["required"]>;
+    selectAllLabel: InputSignal<DBCustomSelectProps["selectAllLabel"]>;
+    removeTagsTexts: InputSignal<DBCustomSelectProps["removeTagsTexts"]>;
+    placement: InputSignal<DBCustomSelectProps["placement"]>;
+    searchFilter: InputSignal<DBCustomSelectProps["searchFilter"]>;
+    className: InputSignal<DBCustomSelectProps["className"]>;
+    formFieldWidth: InputSignal<DBCustomSelectProps["formFieldWidth"]>;
+    variant: InputSignal<DBCustomSelectProps["variant"]>;
+    showRequiredAsterisk: InputSignal<DBCustomSelectProps["showRequiredAsterisk"]>;
+    showLabel: InputSignal<DBCustomSelectProps["showLabel"]>;
+    icon: InputSignal<DBCustomSelectProps["icon"]>;
+    showIcon: InputSignal<DBCustomSelectProps["showIcon"]>;
+    label: InputSignal<DBCustomSelectProps["label"]>;
+    form: InputSignal<DBCustomSelectProps["form"]>;
+    name: InputSignal<DBCustomSelectProps["name"]>;
+    disabled: ModelSignal<DBCustomSelectProps["disabled"]>;
+    open: InputSignal<DBCustomSelectProps["open"]>;
+    dropdownWidth: InputSignal<DBCustomSelectProps["dropdownWidth"]>;
+    searchLabel: InputSignal<DBCustomSelectProps["searchLabel"]>;
+    searchPlaceholder: InputSignal<DBCustomSelectProps["searchPlaceholder"]>;
+    listLabel: InputSignal<DBCustomSelectProps["listLabel"]>;
+    loadingText: InputSignal<DBCustomSelectProps["loadingText"]>;
+    noResultsText: InputSignal<DBCustomSelectProps["noResultsText"]>;
+    mobileCloseButtonText: InputSignal<DBCustomSelectProps["mobileCloseButtonText"]>;
+    showClearSelection: InputSignal<DBCustomSelectProps["showClearSelection"]>;
+    clearSelectionText: InputSignal<DBCustomSelectProps["clearSelectionText"]>;
+    placeholder: InputSignal<DBCustomSelectProps["placeholder"]>;
+    messageIcon: InputSignal<DBCustomSelectProps["messageIcon"]>;
+    amountChange: _angular_core.OutputEmitterRef<number | void>;
+    dropdownToggle: _angular_core.OutputEmitterRef<void | Event>;
+    optionSelected: _angular_core.OutputEmitterRef<void | string[]>;
+    search: _angular_core.OutputEmitterRef<void | Event>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    selectRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    detailsRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    searchInputRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    selectAllRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _messageId: _angular_core.WritableSignal<string | undefined>;
+    _validMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessage: _angular_core.WritableSignal<string | undefined>;
+    _selectId: _angular_core.WritableSignal<string | undefined>;
+    _labelId: _angular_core.WritableSignal<string | undefined>;
+    _summaryId: _angular_core.WritableSignal<string | undefined>;
+    _placeholderId: _angular_core.WritableSignal<string | undefined>;
+    _infoTextId: _angular_core.WritableSignal<string | undefined>;
+    _validity: _angular_core.WritableSignal<"invalid" | "valid" | "no-validation" | undefined>;
+    _userInteraction: _angular_core.WritableSignal<boolean | undefined>;
+    _descByIds: _angular_core.WritableSignal<string | undefined>;
+    _selectedLabels: _angular_core.WritableSignal<string | undefined>;
+    _selectedLabelsId: _angular_core.WritableSignal<string | undefined>;
+    _voiceOverFallback: _angular_core.WritableSignal<string | undefined>;
+    _selectedOptions: _angular_core.WritableSignal<CustomSelectOptionType[] | undefined>;
+    selectAllEnabled: _angular_core.WritableSignal<boolean>;
+    searchEnabled: _angular_core.WritableSignal<boolean>;
+    amountOptions: _angular_core.WritableSignal<number>;
+    _values: _angular_core.WritableSignal<string[] | undefined>;
+    _options: _angular_core.WritableSignal<CustomSelectOptionType[] | undefined>;
+    _hasNoOptions: _angular_core.WritableSignal<boolean>;
+    _documentClickListenerCallbackId: _angular_core.WritableSignal<string | undefined>;
+    _internalChangeTimestamp: _angular_core.WritableSignal<number>;
+    _documentScrollListenerCallbackId: _angular_core.WritableSignal<string | undefined>;
+    _observer: _angular_core.WritableSignal<IntersectionObserver | undefined>;
+    _searchValue: _angular_core.WritableSignal<string | undefined>;
+    selectAllChecked: _angular_core.WritableSignal<boolean>;
+    selectAllIndeterminate: _angular_core.WritableSignal<boolean>;
+    handleDocumentScroll(event: any): void;
+    hasValidState(): boolean;
+    handleValidation(): void;
+    handleDropdownToggle(event: GeneralEvent<HTMLDetailsElement>): void;
+    getNativeSelectValue(): string;
+    setDescById(descId?: string): void;
+    getSelectAllLabel(): string;
+    getOptionLabel(option: CustomSelectOptionType): string;
+    getOptionChecked(value?: string): boolean | undefined;
+    getTagRemoveLabel(option: CustomSelectOptionType): string;
+    handleTagRemove(option: CustomSelectOptionType, event?: ClickEvent<HTMLButtonElement> | void): void;
+    handleAutoPlacement(): void;
+    handleArrowDownUp(event: any): void;
+    handleKeyboardPress(event: any): void;
+    handleClose(event?: InteractionEvent<HTMLDetailsElement> | void, forceClose?: boolean): void;
+    handleDocumentClose(event: any): void;
+    handleOptionSelected(values: string[]): void;
+    handleSelect(value?: string): void;
+    handleSelectAll(event: any): void;
+    handleFocusFirstDropdownCheckbox(activeElement?: Element): void;
+    handleOpenByKeyboardFocus(): void;
+    handleSearch(valueOrEvent?: InputEvent<HTMLInputElement> | string | void): void;
+    handleClearAll(event: any): void;
+    handleSummaryFocus(): void;
+    satisfyReact(event: any): void;
+    trackByOption0(_: number, option: any): string;
+    trackByOption1(index: number, option: any): string;
+    trackByOption2(_: number, option: any): string;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCustomSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCustomSelect, "db-custom-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "showNoResults": { "alias": "showNoResults"; "required": false; "isSignal": true; }; "showLoading": { "alias": "showLoading"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "searchValue": { "alias": "searchValue"; "required": false; "isSignal": true; }; "selectedLabels": { "alias": "selectedLabels"; "required": false; "isSignal": true; }; "transformSelectedLabels": { "alias": "transformSelectedLabels"; "required": false; "isSignal": true; }; "selectedType": { "alias": "selectedType"; "required": false; "isSignal": true; }; "amountText": { "alias": "amountText"; "required": false; "isSignal": true; }; "validMessage": { "alias": "validMessage"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; "isSignal": true; }; "removeTagsTexts": { "alias": "removeTagsTexts"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "searchFilter": { "alias": "searchFilter"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "formFieldWidth": { "alias": "formFieldWidth"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "dropdownWidth": { "alias": "dropdownWidth"; "required": false; "isSignal": true; }; "searchLabel": { "alias": "searchLabel"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "listLabel": { "alias": "listLabel"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "mobileCloseButtonText": { "alias": "mobileCloseButtonText"; "required": false; "isSignal": true; }; "showClearSelection": { "alias": "showClearSelection"; "required": false; "isSignal": true; }; "clearSelectionText": { "alias": "clearSelectionText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "messageIcon": { "alias": "messageIcon"; "required": false; "isSignal": true; }; }, { "values": "valuesChange"; "disabled": "disabledChange"; "amountChange": "amountChange"; "dropdownToggle": "dropdownToggle"; "optionSelected": "optionSelected"; "search": "search"; }, never, ["*"], true, never>;
+}
+
+declare class DBCustomSelectDropdown implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBCustomSelectDropdownProps["id"]>;
+    className: InputSignal<DBCustomSelectDropdownProps["className"]>;
+    width: InputSignal<DBCustomSelectDropdownProps["width"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCustomSelectDropdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCustomSelectDropdown, "db-custom-select-dropdown", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DBCustomSelectFormField implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBCustomSelectFormFieldProps["id"]>;
+    className: InputSignal<DBCustomSelectFormFieldProps["className"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCustomSelectFormField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCustomSelectFormField, "db-custom-select-form-field", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBCustomSelectListDefaultProps = {
+    label?: string;
+    multiple?: boolean;
+};
+type DBCustomSelectListProps = DBCustomSelectListDefaultProps & GlobalProps;
+type DBCustomSelectListDefaultState = {};
+type DBCustomSelectListState = DBCustomSelectListDefaultState & GlobalState;
+
+declare class DBCustomSelectList implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    multiple: InputSignal<DBCustomSelectListProps["multiple"]>;
+    label: InputSignal<DBCustomSelectListProps["label"]>;
+    id: InputSignal<DBCustomSelectListProps["id"]>;
+    className: InputSignal<DBCustomSelectListProps["className"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCustomSelectList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCustomSelectList, "db-custom-select-list", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DBCustomSelectListItem implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    id: InputSignal<DBCustomSelectListItemProps["id"]>;
+    isGroupTitle: InputSignal<DBCustomSelectListItemProps["isGroupTitle"]>;
+    showDivider: InputSignal<DBCustomSelectListItemProps["showDivider"]>;
+    type: InputSignal<DBCustomSelectListItemProps["type"]>;
+    checked: ModelSignal<DBCustomSelectListItemProps["checked"]>;
+    className: InputSignal<DBCustomSelectListItemProps["className"]>;
+    groupTitle: InputSignal<DBCustomSelectListItemProps["groupTitle"]>;
+    icon: InputSignal<DBCustomSelectListItemProps["icon"]>;
+    showIcon: InputSignal<DBCustomSelectListItemProps["showIcon"]>;
+    name: InputSignal<DBCustomSelectListItemProps["name"]>;
+    disabled: ModelSignal<DBCustomSelectListItemProps["disabled"]>;
+    value: InputSignal<DBCustomSelectListItemProps["value"]>;
+    label: InputSignal<DBCustomSelectListItemProps["label"]>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    hasDivider: _angular_core.WritableSignal<boolean | undefined>;
+    handleChange(event: ChangeEvent<HTMLInputElement>): void;
+    getIconTrailing(): "check" | "x_placeholder" | undefined;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBCustomSelectListItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBCustomSelectListItem, "db-custom-select-list-item", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "isGroupTitle": { "alias": "isGroupTitle"; "required": false; "isSignal": true; }; "showDivider": { "alias": "showDivider"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "groupTitle": { "alias": "groupTitle"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "disabled": "disabledChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare const DividerMarginList: readonly ["none", "_"];
+type DividerMarginType = (typeof DividerMarginList)[number];
+declare const DividerVariantList: readonly ["horizontal", "vertical"];
+type DividerVariantType = (typeof DividerVariantList)[number];
+type DBDividerDefaultProps = {
+    /**
+     * Removes the margin of the divider.
+     */
+    margin?: DividerMarginType;
+    /**
+     * Changes the orientation of the divider.
+     */
+    variant?: DividerVariantType;
+};
+type DBDividerProps = DBDividerDefaultProps & GlobalProps & EmphasisProps & MarginProps & WidthProps;
+type DBDividerDefaultState = {};
+type DBDividerState = DBDividerDefaultState & GlobalState;
+
+declare class DBDivider implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBDividerProps["id"]>;
+    margin: InputSignal<DBDividerProps["margin"]>;
+    variant: InputSignal<DBDividerProps["variant"]>;
+    emphasis: InputSignal<DBDividerProps["emphasis"]>;
+    width: InputSignal<DBDividerProps["width"]>;
+    className: InputSignal<DBDividerProps["className"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBDivider, "db-divider", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const DrawerBackdropList: readonly ["none", "strong", "weak", "invisible"];
+type DrawerBackdropType = (typeof DrawerBackdropList)[number];
+declare const DrawerDirectionList: readonly ["left", "right", "up", "down"];
+type DrawerDirectionType = (typeof DrawerDirectionList)[number];
+declare const DrawerVariantList: readonly ["modal", "inside"];
+type DrawerVariantType = (typeof DrawerVariantList)[number];
+declare const DrawerPositionList: readonly ["fixed", "absolute"];
+type DrawerPositionType = (typeof DrawerPositionList)[number];
+type DBDrawerDefaultProps = {
+    /**
+     * The backdrop attribute changes the opacity of the backdrop.
+     * The backdrop 'none' will use `dialog.show()` instead of `dialog.showModal()`
+     */
+    backdrop?: DrawerBackdropType;
+    /**
+     * The direction attribute changes the position & animation of the drawer.
+     * E.g. "left" slides from left screen border to the right.
+     */
+    direction?: DrawerDirectionType;
+    /**
+     * Slot for changing the header of the drawer.
+     */
+    drawerHeader?: any;
+    /**
+     * The open attribute opens or closes the drawer based on the state.
+     */
+    open?: boolean | string;
+    /**
+     * The rounded attribute changes the border radius of the corners on the "end" of the drawer.
+     * The "end" depends on which direction you use.
+     */
+    rounded?: boolean | string;
+    /**
+     * Set the variant modal|inside. Defaults to modal.
+     */
+    variant?: DrawerVariantType;
+    /**
+     * The position attribute changes the css-position (fixed or absolute) of the drawer.
+     *
+     * - `fixed` (default): Renders with `showModal()`, creating a true modal with a focus trap.
+     * - `absolute`: Renders with `show()`, acting as a simple overlay **without** a focus trap.
+     */
+    position?: DrawerPositionType;
+};
+type DBDrawerProps = DBDrawerDefaultProps & GlobalProps & CloseEventProps<ClickEvent<HTMLButtonElement | HTMLDialogElement> | GeneralKeyboardEvent<HTMLDialogElement>> & InnerCloseButtonProps & WidthProps & SpacingProps;
+type DBDrawerDefaultState = {
+    handleDialogOpen: () => void;
+};
+type DBDrawerState = DBDrawerDefaultState & GlobalState & CloseEventState<ClickEvent<HTMLButtonElement | HTMLDialogElement> | GeneralKeyboardEvent<HTMLDialogElement>> & InitializedState;
+
+declare class DBDrawer implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly DEFAULT_CLOSE_BUTTON: string;
+    open: InputSignal<DBDrawerProps["open"]>;
+    position: InputSignal<DBDrawerProps["position"]>;
+    backdrop: InputSignal<DBDrawerProps["backdrop"]>;
+    variant: InputSignal<DBDrawerProps["variant"]>;
+    id: InputSignal<DBDrawerProps["id"]>;
+    direction: InputSignal<DBDrawerProps["direction"]>;
+    className: InputSignal<DBDrawerProps["className"]>;
+    spacing: InputSignal<DBDrawerProps["spacing"]>;
+    width: InputSignal<DBDrawerProps["width"]>;
+    rounded: InputSignal<DBDrawerProps["rounded"]>;
+    closeButtonId: InputSignal<DBDrawerProps["closeButtonId"]>;
+    closeButtonText: InputSignal<DBDrawerProps["closeButtonText"]>;
+    close: _angular_core.OutputEmitterRef<void | KeyboardEvent | MouseEvent | undefined>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    dialogContainerRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    handleClose(event?: ClickEvent<HTMLButtonElement | HTMLDialogElement> | GeneralKeyboardEvent<HTMLDialogElement> | void, forceClose?: boolean): void;
+    handleDialogOpen(): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBDrawer, "db-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "backdrop": { "alias": "backdrop"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "closeButtonId": { "alias": "closeButtonId"; "required": false; "isSignal": true; }; "closeButtonText": { "alias": "closeButtonText"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["[drawer-header]", "*"], true, never>;
+}
+
+type DBHeaderDefaultProps = {
+    /**
+     * Slot to pass in the DBBrand component
+     */
+    brand?: any;
+    /**
+     * Slot to pass in a meta navigation.
+     * - Desktop: Above the regular header
+     * - Mobile: Inside the drawer
+     */
+    metaNavigation?: any;
+    /**
+     * Slot to pass one or more elements like DBButton (e.g. search) as primary action.
+     * - Desktop: Shown next to the main-navigation
+     * - Mobile: Shown next to the brand
+     */
+    primaryAction?: any;
+    /**
+     * Slot to pass one or more elements like DBButton (e.g. profile, language, etc.) as secondary action.
+     * - Desktop: Shown separated by divider at the end of the header
+     * - Mobile: Shown inside the drawer at the bottom.
+     */
+    secondaryAction?: any;
+    /**
+     * Open/closes the drawer for mobile header or if `forceMobile` is true.
+     */
+    drawerOpen?: boolean | string;
+    /**
+     * Forces the header to use mobile layout for desktop as well.
+     * You should only use this setting if you really can't provide a smaller navigation.
+     * Overwrite size of the drawer with '--db-drawer-max-width: xxx'
+     */
+    forceMobile?: boolean | string;
+    /**
+     * This attribute sets the label for the burger menu button for mobile headers.
+     */
+    burgerMenuLabel?: string;
+};
+type DBHeaderProps = DBHeaderDefaultProps & GlobalProps & ToggleEventProps & ContainerWidthProps;
+type DBHeaderDefaultState = {
+    forcedToMobile?: boolean;
+};
+type DBHeaderState = DBHeaderDefaultState & GlobalState & ToggleEventState<HTMLElement> & InitializedState & NavigationBehaviorState;
+
+declare class DBHeader implements AfterViewInit {
+    dbNavigation: any;
+    dbMetaNavigation: any;
+    dbSecondaryAction: any;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly DEFAULT_BURGER_MENU: string;
+    forceMobile: InputSignal<DBHeaderProps["forceMobile"]>;
+    drawerOpen: InputSignal<DBHeaderProps["drawerOpen"]>;
+    className: InputSignal<DBHeaderProps["className"]>;
+    id: InputSignal<DBHeaderProps["id"]>;
+    width: InputSignal<DBHeaderProps["width"]>;
+    burgerMenuLabel: InputSignal<DBHeaderProps["burgerMenuLabel"]>;
+    toggle: _angular_core.OutputEmitterRef<boolean | void>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    forcedToMobile: _angular_core.WritableSignal<boolean | undefined>;
+    handleToggle(event?: any): void;
+    handleNavigationItemClick(event: unknown): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBHeader, "db-header", never, { "forceMobile": { "alias": "forceMobile"; "required": false; "isSignal": true; }; "drawerOpen": { "alias": "drawerOpen"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "burgerMenuLabel": { "alias": "burgerMenuLabel"; "required": false; "isSignal": true; }; }, { "toggle": "toggle"; }, ["dbNavigation", "dbMetaNavigation", "dbSecondaryAction"], ["*", "*", "*", "*", "[brand]", "*", "[primary-action]", "*"], true, never>;
+}
+
+declare class SecondaryActionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SecondaryActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SecondaryActionDirective, "[dbSecondaryAction]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MetaNavigationDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MetaNavigationDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MetaNavigationDirective, "[dbMetaNavigation]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NavigationDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationDirective, "[dbNavigation]", never, {}, {}, never, never, true, never>;
+}
+
+declare const IconWeightList: readonly ["16", "20", "24", "32", "48", "64"];
+type IconWeightType = (typeof IconWeightList)[number];
+type DBIconDefaultProps = {
+    variant?: string;
+    weight?: IconWeightType;
+};
+type DBIconProps = DBIconDefaultProps & GlobalProps & IconProps & TextProps;
+type DBIconDefaultState = {};
+type DBIconState = DBIconDefaultState & GlobalState;
+
+declare class DBIcon implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBIconProps["id"]>;
+    className: InputSignal<DBIconProps["className"]>;
+    icon: InputSignal<DBIconProps["icon"]>;
+    weight: InputSignal<DBIconProps["weight"]>;
+    variant: InputSignal<DBIconProps["variant"]>;
+    text: InputSignal<DBIconProps["text"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBIcon, "db-icon", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBInfotextDefaultProps = {};
+type DBInfotextProps = DBInfotextDefaultProps & GlobalProps & SemanticProps & IconProps & SizeProps & ShowIconProps & TextProps;
+type DBInfotextDefaultState = {};
+type DBInfotextState = DBInfotextDefaultState & GlobalState;
+
+declare class DBInfotext implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    id: InputSignal<DBInfotextProps["id"]>;
+    className: InputSignal<DBInfotextProps["className"]>;
+    icon: InputSignal<DBInfotextProps["icon"]>;
+    semantic: InputSignal<DBInfotextProps["semantic"]>;
+    size: InputSignal<DBInfotextProps["size"]>;
+    showIcon: InputSignal<DBInfotextProps["showIcon"]>;
+    text: InputSignal<DBInfotextProps["text"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBInfotext, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBInfotext, "db-infotext", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "semantic": { "alias": "semantic"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const InputTypeList: readonly ["color", "date", "datetime-local", "email", "file", "hidden", "month", "number", "password", "range", "search", "tel", "text", "time", "url", "week"];
+type InputTypeType = (typeof InputTypeList)[number];
+type DBInputDefaultProps = {
+    /**
+     * Set a [data list](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist) via attribute instead of children.
+     */
+    dataList?: string[] | ValueLabelType[];
+    /**
+     * Add a custom id to [data list](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist) if you're using `dataList` attribute.
+     */
+    dataListId?: string;
+    /**
+     * Allow selecting multiple files. https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/file#multiple
+     */
+    multiple?: boolean | string;
+    /**
+     * Maximum value
+     */
+    max?: number | string;
+    /**
+     * Minimum value
+     */
+    min?: number | string;
+    /**
+     * Pattern the value must match to be valid
+     */
+    pattern?: string;
+    /**
+     * 	Type of form control
+     */
+    type?: InputTypeType | string;
+    /**
+     * Sets [step value](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step).
+     */
+    step?: number | string;
+    /**
+     * Hint for the [enter key behavior](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/enterkeyhint) on virtual keyboards.
+     */
+    enterkeyhint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+    /**
+     * Hint for [virtual keyboard](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inputmode) selection.
+     */
+    inputmode?: 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+    /**
+     * The size of the message infotext. Defaults to "small".
+     */
+    messageSize?: SizeType;
+    /**
+     * The size of the valid message infotext. Defaults to "small".
+     */
+    validMessageSize?: SizeType;
+    /**
+     * The size of the invalid message infotext. Defaults to "small".
+     */
+    invalidMessageSize?: SizeType;
+};
+type DBInputProps = DBInputDefaultProps & GlobalProps & FormTextProps & InputEventProps<HTMLInputElement> & ChangeEventProps<HTMLInputElement> & FocusEventProps<HTMLInputElement> & FormProps & IconProps & IconTrailingProps & FormMessageProps & ShowIconProps & IconLeadingProps & ShowIconLeadingProps & ShowIconTrailingProps & FormSizeProps;
+type DBInputDefaultState = {
+    _dataListId?: string;
+    getDataList: () => ValueLabelType[];
+};
+type DBInputState = DBInputDefaultState & GlobalState & InputEventState<HTMLInputElement> & ChangeEventState<HTMLInputElement> & FocusEventState<HTMLInputElement> & FormState & FromValidState;
+
+declare class DBInput implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly DEFAULT_LABEL: string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly DEFAULT_PLACEHOLDER: string;
+    protected readonly getNumber: (originNumber?: number | string, alternativeNumber?: number | string) => number | undefined;
+    protected readonly getInputValue: (value?: number | string, inputType?: string) => string | number | undefined;
+    protected readonly isIOSSafari: () => boolean;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly DEFAULT_VALID_MESSAGE: string;
+    id: InputSignal<DBInputProps["id"]>;
+    invalidMessage: InputSignal<DBInputProps["invalidMessage"]>;
+    dataListId: InputSignal<DBInputProps["dataListId"]>;
+    message: InputSignal<DBInputProps["message"]>;
+    showMessage: InputSignal<DBInputProps["showMessage"]>;
+    value: ModelSignal<DBInputProps["value"]>;
+    validMessage: InputSignal<DBInputProps["validMessage"]>;
+    validation: InputSignal<DBInputProps["validation"]>;
+    required: InputSignal<DBInputProps["required"]>;
+    minLength: InputSignal<DBInputProps["minLength"]>;
+    maxLength: InputSignal<DBInputProps["maxLength"]>;
+    pattern: InputSignal<DBInputProps["pattern"]>;
+    dataList: InputSignal<DBInputProps["dataList"]>;
+    className: InputSignal<DBInputProps["className"]>;
+    variant: InputSignal<DBInputProps["variant"]>;
+    showLabel: InputSignal<DBInputProps["showLabel"]>;
+    showIconLeading: InputSignal<DBInputProps["showIconLeading"]>;
+    showIcon: InputSignal<DBInputProps["showIcon"]>;
+    iconLeading: InputSignal<DBInputProps["iconLeading"]>;
+    icon: InputSignal<DBInputProps["icon"]>;
+    iconTrailing: InputSignal<DBInputProps["iconTrailing"]>;
+    showRequiredAsterisk: InputSignal<DBInputProps["showRequiredAsterisk"]>;
+    showIconTrailing: InputSignal<DBInputProps["showIconTrailing"]>;
+    label: InputSignal<DBInputProps["label"]>;
+    fieldSizing: InputSignal<DBInputProps["fieldSizing"]>;
+    name: InputSignal<DBInputProps["name"]>;
+    type: InputSignal<DBInputProps["type"]>;
+    multiple: InputSignal<DBInputProps["multiple"]>;
+    placeholder: InputSignal<DBInputProps["placeholder"]>;
+    disabled: ModelSignal<DBInputProps["disabled"]>;
+    step: InputSignal<DBInputProps["step"]>;
+    maxlength: InputSignal<DBInputProps["maxlength"]>;
+    minlength: InputSignal<DBInputProps["minlength"]>;
+    max: InputSignal<DBInputProps["max"]>;
+    min: InputSignal<DBInputProps["min"]>;
+    readOnly: InputSignal<DBInputProps["readOnly"]>;
+    readonly: InputSignal<DBInputProps["readonly"]>;
+    form: InputSignal<DBInputProps["form"]>;
+    size: InputSignal<DBInputProps["size"]>;
+    autocomplete: InputSignal<DBInputProps["autocomplete"]>;
+    autofocus: InputSignal<DBInputProps["autofocus"]>;
+    enterkeyhint: InputSignal<DBInputProps["enterkeyhint"]>;
+    inputmode: InputSignal<DBInputProps["inputmode"]>;
+    ariaDescribedBy: InputSignal<DBInputProps["ariaDescribedBy"]>;
+    messageSize: InputSignal<DBInputProps["messageSize"]>;
+    messageIcon: InputSignal<DBInputProps["messageIcon"]>;
+    validMessageSize: InputSignal<DBInputProps["validMessageSize"]>;
+    invalidMessageSize: InputSignal<DBInputProps["invalidMessageSize"]>;
+    input: _angular_core.OutputEmitterRef<void | Event>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    blur: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    focus: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _messageId: _angular_core.WritableSignal<string | undefined>;
+    _validMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessage: _angular_core.WritableSignal<string | undefined>;
+    _dataListId: _angular_core.WritableSignal<string | undefined>;
+    _descByIds: _angular_core.WritableSignal<string | undefined>;
+    _value: _angular_core.WritableSignal<string | undefined>;
+    _voiceOverFallback: _angular_core.WritableSignal<string | undefined>;
+    hasValidState(): boolean;
+    handleValidation(): void;
+    handleInput(event: InputEvent<HTMLInputElement>): void;
+    handleChange(event: ChangeEvent<HTMLInputElement>): void;
+    handleBlur(event: InteractionEvent<HTMLInputElement> | any): void;
+    handleFocus(event: InteractionEvent<HTMLInputElement> | any): void;
+    getDataList(): ValueLabelType[];
+    trackByOption0(_: number, option: any): string;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBInput, "db-input", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "dataListId": { "alias": "dataListId"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "validMessage": { "alias": "validMessage"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "dataList": { "alias": "dataList"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showIconLeading": { "alias": "showIconLeading"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "iconLeading": { "alias": "iconLeading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconTrailing": { "alias": "iconTrailing"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "showIconTrailing": { "alias": "showIconTrailing"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fieldSizing": { "alias": "fieldSizing"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "enterkeyhint": { "alias": "enterkeyhint"; "required": false; "isSignal": true; }; "inputmode": { "alias": "inputmode"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "messageSize": { "alias": "messageSize"; "required": false; "isSignal": true; }; "messageIcon": { "alias": "messageIcon"; "required": false; "isSignal": true; }; "validMessageSize": { "alias": "validMessageSize"; "required": false; "isSignal": true; }; "invalidMessageSize": { "alias": "invalidMessageSize"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; "input": "input"; "change": "change"; "blur": "blur"; "focus": "focus"; }, never, ["*"], true, never>;
+}
+
+declare const LinkVariantList: readonly ["adaptive", "brand", "inline"];
+type LinkVariantType = (typeof LinkVariantList)[number];
+declare const LinkSizeList: readonly ["medium", "small"];
+type LinkSizeType = (typeof LinkSizeList)[number];
+declare const LinkContentList: readonly ["external", "internal"];
+type LinkContentType = (typeof LinkContentList)[number];
+type DBLinkDefaultProps = {
+    /**
+     * Adds a different arrow after the link to indicate external or internal link
+     */
+    content?: LinkContentType;
+    /**
+     * Change the size of the link
+     */
+    size?: LinkSizeType;
+    /**
+     * Change the styling of the link. `inline` will remove the arrow. Defaults to adaptive.
+     */
+    variant?: LinkVariantType;
+};
+type DBLinkProps = DBLinkDefaultProps & GlobalProps & ClickEventProps<HTMLAnchorElement> & LinkProps & ShowIconProps & TextProps & WrapProps;
+type DBLinkDefaultState = {};
+type DBLinkState = DBLinkDefaultState & GlobalState & ClickEventState<HTMLAnchorElement>;
+
+declare class DBLink implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    id: InputSignal<DBLinkProps["id"]>;
+    className: InputSignal<DBLinkProps["className"]>;
+    href: InputSignal<DBLinkProps["href"]>;
+    target: InputSignal<DBLinkProps["target"]>;
+    rel: InputSignal<DBLinkProps["rel"]>;
+    role: InputSignal<DBLinkProps["role"]>;
+    hreflang: InputSignal<DBLinkProps["hreflang"]>;
+    disabled: InputSignal<DBLinkProps["disabled"]>;
+    size: InputSignal<DBLinkProps["size"]>;
+    showIcon: InputSignal<DBLinkProps["showIcon"]>;
+    variant: InputSignal<DBLinkProps["variant"]>;
+    content: InputSignal<DBLinkProps["content"]>;
+    wrap: InputSignal<DBLinkProps["wrap"]>;
+    text: InputSignal<DBLinkProps["text"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBLink, "db-link", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "rel": { "alias": "rel"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "hreflang": { "alias": "hreflang"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBNavigationDefaultProps = {};
+type DBNavigationProps = DBNavigationDefaultProps & GlobalProps;
+type DBNavigationDefaultState = {};
+type DBNavigationState = DBNavigationDefaultState & GlobalState;
+
+declare class DBNavigation implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBNavigationProps["id"]>;
+    className: InputSignal<DBNavigationProps["className"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBNavigation, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBNavigation, "db-navigation", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type TriangleData = {
+    itemRect: DOMRect;
+    parentElementWidth: number;
+    subNavigationHeight: number;
+    padding: number;
+    outsideVX: 'left' | 'right' | undefined;
+    outsideVY: 'top' | 'bottom' | undefined;
+};
+declare const isEventTargetNavigationItem: (event: unknown) => boolean;
+declare class NavigationItemSafeTriangle {
+    private readonly element;
+    private readonly subNavigation;
+    private readonly parentSubNavigation;
+    private triangleData?;
+    private initialized;
+    private mouseX;
+    private mouseY;
+    constructor(element: HTMLElement | null, subNavigation: HTMLElement | null);
+    private init;
+    enableFollow(): void;
+    disableFollow(): void;
+    private getTriangleTipX;
+    private getTriangleTipY;
+    private hasMouseEnteredSubNavigation;
+    private getTriangleCoordinates;
+    followByMouseEvent(event: MouseEvent): void;
+}
+
+type DBNavigationItemDefaultProps = {
+    /**
+     * Alternative indicator for active navigation item (bold font). In contrast to the use of aria-current="page" on the contained anchor, this does not guarantee correct a11y.
+     */
+    active?: boolean;
+    /**
+     * The disabled attribute can be set to [keep a user from clicking on the item](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#disabled).
+     */
+    disabled?: boolean | string;
+    /**
+     * React-specific property to pass in a slot for sub-navigation
+     */
+    subNavigation?: any;
+    /**
+     * This is for mobile navigation only, if it is set the sub-navigation is a static overlay
+     */
+    subNavigationExpanded?: boolean | string;
+};
+type DBNavigationItemProps = DBNavigationItemDefaultProps & GlobalProps & ClickEventProps<HTMLButtonElement> & IconProps & WidthProps & WrapProps & NavigationBackButtonProps & ShowIconProps & TextProps;
+type DBNavigationItemDefaultState = {
+    handleBackClick: (event: ClickEvent<HTMLButtonElement>) => void;
+    hasAreaPopup: boolean;
+    isSubNavigationExpanded: boolean;
+    subNavigationId: string;
+    /**
+     * Internal state property to show/hide sub-navigation button
+     */
+    hasSubNavigation?: boolean;
+    navigationItemSafeTriangle?: NavigationItemSafeTriangle;
+    autoClose?: boolean;
+};
+type DBNavigationItemState = DBNavigationItemDefaultState & ClickEventState<HTMLButtonElement> & GlobalState & InitializedState & NavigationBehaviorState;
+
+declare class DBNavigationItem implements AfterViewInit {
+    dbNavigationContent: any;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly DEFAULT_BACK: string;
+    subNavigationExpanded: InputSignal<DBNavigationItemProps["subNavigationExpanded"]>;
+    id: InputSignal<DBNavigationItemProps["id"]>;
+    className: InputSignal<DBNavigationItemProps["className"]>;
+    width: InputSignal<DBNavigationItemProps["width"]>;
+    icon: InputSignal<DBNavigationItemProps["icon"]>;
+    showIcon: InputSignal<DBNavigationItemProps["showIcon"]>;
+    active: InputSignal<DBNavigationItemProps["active"]>;
+    wrap: InputSignal<DBNavigationItemProps["wrap"]>;
+    disabled: InputSignal<DBNavigationItemProps["disabled"]>;
+    text: InputSignal<DBNavigationItemProps["text"]>;
+    backButtonId: InputSignal<DBNavigationItemProps["backButtonId"]>;
+    backButtonText: InputSignal<DBNavigationItemProps["backButtonText"]>;
+    click: _angular_core.OutputEmitterRef<void | MouseEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    hasAreaPopup: _angular_core.WritableSignal<boolean>;
+    hasSubNavigation: _angular_core.WritableSignal<boolean | undefined>;
+    isSubNavigationExpanded: _angular_core.WritableSignal<boolean>;
+    autoClose: _angular_core.WritableSignal<boolean | undefined>;
+    subNavigationId: _angular_core.WritableSignal<string>;
+    navigationItemSafeTriangle: _angular_core.WritableSignal<NavigationItemSafeTriangle | undefined>;
+    handleNavigationItemClick(event: any): void;
+    handleClick(event: ClickEvent<HTMLButtonElement> | any): void;
+    handleBackClick(event: ClickEvent<HTMLButtonElement> | any): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBNavigationItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBNavigationItem, "db-navigation-item", never, { "subNavigationExpanded": { "alias": "subNavigationExpanded"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "backButtonId": { "alias": "backButtonId"; "required": false; "isSignal": true; }; "backButtonText": { "alias": "backButtonText"; "required": false; "isSignal": true; }; }, { "click": "click"; }, ["dbNavigationContent"], ["*", "*", "[sub-navigation]"], true, never>;
+}
+
+declare class NavigationContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationContentDirective, "[dbNavigationContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare const NotificationVariantList: readonly ["docked", "standalone", "overlay"];
+type NotificationVariantType = (typeof NotificationVariantList)[number];
+declare const NotificationLinkVariantList: readonly ["block", "inline"];
+type NotificationLinkVariantType = (typeof NotificationLinkVariantList)[number];
+declare const NotificationAriaLiveList: readonly ["assertive", "polite", "off"];
+type NotificationAriaLiveType = (typeof NotificationAriaLiveList)[number];
+type DBNotificationDefaultProps = {
+    /**
+     * The arialive attribute will lead to that the screenreader interrupts immediately
+     * and reads out the notification if set to "assertive", while it will wait for the
+     * user's idleness when set to "polite", compare to [aria-live](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-live)
+     */
+    ariaLive?: NotificationAriaLiveType;
+    /**
+     * The closeable attribute shows/hides the close button on the top right.
+     */
+    closeable?: boolean | string;
+    /**
+     * The headline attribute changes the text of the bold headline.
+     */
+    headline?: string | any;
+    /**
+     * The slotImage can be set instead of an icon.
+     */
+    image?: any;
+    /**
+     * The slotLink can be set for non overlay-notifications
+     */
+    link?: any;
+    /**
+     * The linkVariant will be used if slotLink is set.
+     */
+    linkVariant?: NotificationLinkVariantType;
+    /**
+     * Enables or disables the visibility of the headline.
+     */
+    showHeadline?: boolean | string;
+    /**
+     * The timestamp attribute can be set for overlay notifications
+     */
+    timestamp?: string;
+    /**
+     * Enables or disables the visibility of the timestamp.
+     */
+    showTimestamp?: boolean | string;
+    /**
+     * The variant attribute changes the styling of the notification.
+     * - The docked notifications are used e.g. between header and main content to show a global alert.
+     * - The standalone notifications are used  e.g. inside a form to show an alert for a specific field.
+     * - The overlay notifications are used for absolute and floating notifications like snackbars etc.
+     */
+    variant?: NotificationVariantType;
+};
+type DBNotificationProps = DBNotificationDefaultProps & GlobalProps & CloseEventProps<ClickEvent<HTMLButtonElement>> & IconProps & SemanticProps & InnerCloseButtonProps & PopoverProps & ShowIconProps & TextProps;
+type DBNotificationDefaultState = {};
+type DBNotificationState = DBNotificationDefaultState & GlobalState & CloseEventState<ClickEvent<HTMLButtonElement>>;
+
+declare class DBNotification implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly DEFAULT_CLOSE_BUTTON: string;
+    id: InputSignal<DBNotificationProps["id"]>;
+    className: InputSignal<DBNotificationProps["className"]>;
+    ariaLive: InputSignal<DBNotificationProps["ariaLive"]>;
+    semantic: InputSignal<DBNotificationProps["semantic"]>;
+    variant: InputSignal<DBNotificationProps["variant"]>;
+    icon: InputSignal<DBNotificationProps["icon"]>;
+    showIcon: InputSignal<DBNotificationProps["showIcon"]>;
+    linkVariant: InputSignal<DBNotificationProps["linkVariant"]>;
+    headline: InputSignal<DBNotificationProps["headline"]>;
+    showHeadline: InputSignal<DBNotificationProps["showHeadline"]>;
+    text: InputSignal<DBNotificationProps["text"]>;
+    timestamp: InputSignal<DBNotificationProps["timestamp"]>;
+    showTimestamp: InputSignal<DBNotificationProps["showTimestamp"]>;
+    closeable: InputSignal<DBNotificationProps["closeable"]>;
+    closeButtonId: InputSignal<DBNotificationProps["closeButtonId"]>;
+    closeButtonText: InputSignal<DBNotificationProps["closeButtonText"]>;
+    close: _angular_core.OutputEmitterRef<void | MouseEvent | undefined>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    handleClose(event?: ClickEvent<HTMLButtonElement> | void): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBNotification, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBNotification, "db-notification", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "ariaLive": { "alias": "ariaLive"; "required": false; "isSignal": true; }; "semantic": { "alias": "semantic"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "linkVariant": { "alias": "linkVariant"; "required": false; "isSignal": true; }; "headline": { "alias": "headline"; "required": false; "isSignal": true; }; "showHeadline": { "alias": "showHeadline"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "timestamp": { "alias": "timestamp"; "required": false; "isSignal": true; }; "showTimestamp": { "alias": "showTimestamp"; "required": false; "isSignal": true; }; "closeable": { "alias": "closeable"; "required": false; "isSignal": true; }; "closeButtonId": { "alias": "closeButtonId"; "required": false; "isSignal": true; }; "closeButtonText": { "alias": "closeButtonText"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["[image]", "*", "[link]"], true, never>;
+}
+
+declare const PageVariantList: readonly ["auto", "fixed"];
+type PageVariantType = (typeof PageVariantList)[number];
+declare const PageDocumentOverflowList: readonly ["hidden", "auto"];
+type PageDocumentOverflowType = (typeof PageDocumentOverflowList)[number];
+type DBPageDefaultProps = {
+    /**
+     * The documentOverflow sets the overflow:hidden/auto to the root document
+     */
+    documentOverflow?: PageDocumentOverflowType;
+    /**
+     * Set this to have a transition with opacity to avoid layout-shifts https://simonhearne.com/2021/layout-shifts-webfonts/
+     */
+    fadeIn?: boolean | string;
+    /**
+     * The slot can be used for React to set a footer.
+     */
+    footer?: any;
+    /**
+     * The slot can be used for React to set a header.
+     */
+    header?: any;
+    /**
+     * Adds `class` to `<main>` element
+     */
+    mainClass?: string;
+    /**
+     * The variant=fixed uses flex-box to make header and footer static
+     */
+    variant?: PageVariantType;
+};
+type DBPageProps = DBPageDefaultProps & GlobalProps;
+type DBPageDefaultState = {
+    fontsLoaded?: boolean;
+};
+type DBPageState = DBPageDefaultState & GlobalState;
+
+declare class DBPage implements AfterViewInit, OnDestroy {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    fadeIn: InputSignal<DBPageProps["fadeIn"]>;
+    documentOverflow: InputSignal<DBPageProps["documentOverflow"]>;
+    variant: InputSignal<DBPageProps["variant"]>;
+    id: InputSignal<DBPageProps["id"]>;
+    className: InputSignal<DBPageProps["className"]>;
+    mainClass: InputSignal<DBPageProps["mainClass"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    fontsLoaded: _angular_core.WritableSignal<boolean | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBPage, "db-page", never, { "fadeIn": { "alias": "fadeIn"; "required": false; "isSignal": true; }; "documentOverflow": { "alias": "documentOverflow"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "mainClass": { "alias": "mainClass"; "required": false; "isSignal": true; }; }, {}, never, ["[header]", "*", "[footer]"], true, never>;
+}
+
+type DBPopoverDefaultProps = {
+    /**
+     * Use open to disable the default hover/focus behavior to use it on click or other trigger.
+     */
+    open?: boolean | string;
+    /**
+     * The trigger to open the popover e.g. a button
+     */
+    trigger?: any;
+};
+type DBPopoverProps = DBPopoverDefaultProps & GlobalProps & SpacingProps & PlacementProps & GapProps & PopoverProps;
+type DBPopoverDefaultState = {
+    isExpanded?: boolean;
+    getTrigger: () => Element | null;
+};
+type DBPopoverState = DBPopoverDefaultState & GlobalState & PopoverState & InitializedState;
+
+declare class DBPopover implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    placement: InputSignal<DBPopoverProps["placement"]>;
+    id: InputSignal<DBPopoverProps["id"]>;
+    className: InputSignal<DBPopoverProps["className"]>;
+    spacing: InputSignal<DBPopoverProps["spacing"]>;
+    gap: InputSignal<DBPopoverProps["gap"]>;
+    animation: InputSignal<DBPopoverProps["animation"]>;
+    open: InputSignal<DBPopoverProps["open"]>;
+    delay: InputSignal<DBPopoverProps["delay"]>;
+    width: InputSignal<DBPopoverProps["width"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    isExpanded: _angular_core.WritableSignal<boolean | undefined>;
+    _documentScrollListenerCallbackId: _angular_core.WritableSignal<string | undefined>;
+    _observer: _angular_core.WritableSignal<IntersectionObserver | undefined>;
+    handleEscape(event: any): void;
+    handleAutoPlacement(): void;
+    handleDocumentScroll(event: any): void;
+    handleEnter(): void;
+    handleLeave(event?: any): void;
+    getTrigger(): Element | null;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBPopover, "db-popover", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, ["[trigger]", "*"], true, never>;
+}
+
+type DBRadioDefaultProps = {};
+type DBRadioProps = DBRadioDefaultProps & GlobalProps & ChangeEventProps<HTMLInputElement> & FocusEventProps<HTMLInputElement> & FormProps & FormCheckProps & SizeProps;
+type DBRadioDefaultState = {};
+type DBRadioState = DBRadioDefaultState & GlobalState & ChangeEventState<HTMLInputElement> & FocusEventState<HTMLInputElement> & FormState & InitializedState;
+
+declare class DBRadio implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    id: InputSignal<DBRadioProps["id"]>;
+    checked: InputSignal<DBRadioProps["checked"]>;
+    size: InputSignal<DBRadioProps["size"]>;
+    showLabel: InputSignal<DBRadioProps["showLabel"]>;
+    showRequiredAsterisk: InputSignal<DBRadioProps["showRequiredAsterisk"]>;
+    className: InputSignal<DBRadioProps["className"]>;
+    validation: InputSignal<DBRadioProps["validation"]>;
+    name: InputSignal<DBRadioProps["name"]>;
+    disabled: ModelSignal<DBRadioProps["disabled"]>;
+    value: ModelSignal<DBRadioProps["value"]>;
+    required: InputSignal<DBRadioProps["required"]>;
+    label: InputSignal<DBRadioProps["label"]>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    blur: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    focus: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    handleChange(event: ChangeEvent<HTMLInputElement> | any): void;
+    handleBlur(event: InteractionEvent<HTMLInputElement> | any): void;
+    handleFocus(event: InteractionEvent<HTMLInputElement> | any): void;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBRadio, "db-radio", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "value": "valueChange"; "change": "change"; "blur": "blur"; "focus": "focus"; }, never, ["*"], true, never>;
+}
+
+type DBSectionDefaultProps = {};
+type DBSectionProps = DBSectionDefaultProps & GlobalProps & SpacingProps & ContainerWidthProps;
+type DBSectionDefaultState = {};
+type DBSectionState = DBSectionDefaultState & GlobalState;
+
+declare class DBSection implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBSectionProps["id"]>;
+    className: InputSignal<DBSectionProps["className"]>;
+    spacing: InputSignal<DBSectionProps["spacing"]>;
+    width: InputSignal<DBSectionProps["width"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBSection, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBSection, "db-section", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBSelectDefaultProps = {
+    /**
+     * @deprecated
+     * Enables multiple select, but it isn't styled, please use DBCustomSelect/db-custom-select instead
+     */
+    multiple?: boolean;
+    /**
+     * If you don't/can't use children/slots you can pass in the options as an array.
+     */
+    options?: DBSelectOptionType[];
+};
+type DBSelectOptionType = {
+    /**
+     * Identifier for option
+     */
+    id?: string;
+    /**
+     * Disables this option
+     */
+    disabled?: boolean;
+    /**
+     * Selects this option
+     */
+    selected?: boolean;
+    /**
+     * If the value is different from the label you want to show to the user.
+     */
+    label?: string;
+    /**
+     * If you want to use optgroup you can nest options here.
+     */
+    options?: DBSelectOptionType[];
+    /**
+     * The main value you select, will be shown as default label if no label is set.
+     */
+    value: string | string[] | number;
+};
+type DBSelectProps = GlobalProps & ClickEventProps<HTMLSelectElement> & ChangeEventProps<HTMLSelectElement> & FocusEventProps<HTMLSelectElement> & InputEventProps<HTMLSelectElement> & FormProps & IconProps & FormMessageProps & DBSelectDefaultProps & ShowIconProps & FormSizeProps;
+type DBSelectDefaultState = {
+    _placeholderId: string;
+    getOptionLabel: (option: DBSelectOptionType) => string;
+};
+type DBSelectState = DBSelectDefaultState & GlobalState & ClickEventState<HTMLSelectElement> & ChangeEventState<HTMLSelectElement> & FocusEventState<HTMLSelectElement> & InputEventState<HTMLSelectElement> & FormState & InitializedState & FromValidState;
+
+declare class DBSelect implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly DEFAULT_LABEL: string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly getOptionKey: (option: {
+        id?: string;
+        value?: string | number | string[] | undefined;
+    }, prefix: string) => string;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly DEFAULT_VALID_MESSAGE: string;
+    id: InputSignal<DBSelectProps["id"]>;
+    invalidMessage: InputSignal<DBSelectProps["invalidMessage"]>;
+    message: InputSignal<DBSelectProps["message"]>;
+    showMessage: InputSignal<DBSelectProps["showMessage"]>;
+    placeholder: InputSignal<DBSelectProps["placeholder"]>;
+    value: ModelSignal<DBSelectProps["value"]>;
+    validMessage: InputSignal<DBSelectProps["validMessage"]>;
+    validation: InputSignal<DBSelectProps["validation"]>;
+    required: InputSignal<DBSelectProps["required"]>;
+    className: InputSignal<DBSelectProps["className"]>;
+    variant: InputSignal<DBSelectProps["variant"]>;
+    showLabel: InputSignal<DBSelectProps["showLabel"]>;
+    showRequiredAsterisk: InputSignal<DBSelectProps["showRequiredAsterisk"]>;
+    icon: InputSignal<DBSelectProps["icon"]>;
+    showIcon: InputSignal<DBSelectProps["showIcon"]>;
+    label: InputSignal<DBSelectProps["label"]>;
+    disabled: ModelSignal<DBSelectProps["disabled"]>;
+    name: InputSignal<DBSelectProps["name"]>;
+    size: InputSignal<DBSelectProps["size"]>;
+    autocomplete: InputSignal<DBSelectProps["autocomplete"]>;
+    multiple: InputSignal<DBSelectProps["multiple"]>;
+    ariaDescribedBy: InputSignal<DBSelectProps["ariaDescribedBy"]>;
+    options: InputSignal<DBSelectProps["options"]>;
+    messageIcon: InputSignal<DBSelectProps["messageIcon"]>;
+    click: _angular_core.OutputEmitterRef<void | MouseEvent>;
+    input: _angular_core.OutputEmitterRef<void | Event>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    blur: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    focus: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _messageId: _angular_core.WritableSignal<string | undefined>;
+    _validMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessage: _angular_core.WritableSignal<string | undefined>;
+    _placeholderId: _angular_core.WritableSignal<string>;
+    _descByIds: _angular_core.WritableSignal<string | undefined>;
+    _value: _angular_core.WritableSignal<string | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    _voiceOverFallback: _angular_core.WritableSignal<string | undefined>;
+    hasValidState(): boolean;
+    handleValidation(): void;
+    handleClick(event: ClickEvent<HTMLSelectElement> | any): void;
+    handleInput(event: InputEvent<HTMLSelectElement> | any): void;
+    handleChange(event: ChangeEvent<HTMLSelectElement> | any): void;
+    handleBlur(event: InteractionEvent<HTMLSelectElement> | any): void;
+    handleFocus(event: InteractionEvent<HTMLSelectElement> | any): void;
+    getOptionLabel(option: DBSelectOptionType): string;
+    trackByOptgroupOption0(_: number, optgroupOption: any): string;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBSelect, "db-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "validMessage": { "alias": "validMessage"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "messageIcon": { "alias": "messageIcon"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; "click": "click"; "input": "input"; "change": "change"; "blur": "blur"; "focus": "focus"; }, never, ["*"], true, never>;
+}
+
+declare const StackVariantList: readonly ["simple", "divider"];
+type StackVariantType = (typeof StackVariantList)[number];
+declare const StackDirectionList: readonly ["row", "column"];
+type StackDirectionType = (typeof StackDirectionList)[number];
+declare const StackAlignmentList: readonly ["stretch", "start", "end", "center"];
+type StackAlignmentType = (typeof StackAlignmentList)[number];
+declare const StackJustifyContentList: readonly ["space-between", "start", "end", "center"];
+type StackJustifyContentType = (typeof StackJustifyContentList)[number];
+type DBStackDefaultProps = {
+    /**
+     * Change variant of stack. To use variant="divider" add a DBDivider after each element
+     */
+    variant?: StackVariantType;
+    /**
+     * Set the direction of the stack. Defaults to "column"
+     */
+    direction?: StackDirectionType;
+    /**
+     * If the stack should wrap if parent is too small otherwise you get an overflow
+     */
+    wrap?: boolean | string;
+    /**
+     * Represents css align-items
+     */
+    alignment?: StackAlignmentType;
+    /**
+     * Represents css justify-content
+     */
+    justifyContent?: StackJustifyContentType;
+};
+type DBStackProps = DBStackDefaultProps & GlobalProps & GapSpacingProps;
+type DBStackDefaultState = {};
+type DBStackState = DBStackDefaultState & GlobalState;
+
+declare class DBStack implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    id: InputSignal<DBStackProps["id"]>;
+    className: InputSignal<DBStackProps["className"]>;
+    gap: InputSignal<DBStackProps["gap"]>;
+    variant: InputSignal<DBStackProps["variant"]>;
+    direction: InputSignal<DBStackProps["direction"]>;
+    alignment: InputSignal<DBStackProps["alignment"]>;
+    justifyContent: InputSignal<DBStackProps["justifyContent"]>;
+    wrap: InputSignal<DBStackProps["wrap"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBStack, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBStack, "db-stack", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "justifyContent": { "alias": "justifyContent"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBSwitchDefaultProps = {
+    /**
+     * Add additional icons to indicate active/inactive state.
+     */
+    visualAid?: boolean | string;
+    /**
+     * Change the variant of the label to `trailing` or `leading`. Defaults to `trailing`
+     */
+    variant?: LabelVariantHorizontalType;
+};
+type DBSwitchProps = GlobalProps & ChangeEventProps<HTMLInputElement> & FocusEventProps<HTMLInputElement> & FormProps & FormCheckProps & FormMessageProps & SizeProps & IconProps & IconTrailingProps & IconLeadingProps & DBSwitchDefaultProps;
+type DBSwitchDefaultState = {};
+type DBSwitchState = DBSwitchDefaultState & GlobalState & ChangeEventState<HTMLInputElement> & FocusEventState<HTMLInputElement> & FormState & FromValidState;
+
+declare class DBSwitch implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly DEFAULT_VALID_MESSAGE: string;
+    protected readonly DEFAULT_INVALID_MESSAGE: string;
+    id: InputSignal<DBSwitchProps["id"]>;
+    validation: InputSignal<DBSwitchProps["validation"]>;
+    required: InputSignal<DBSwitchProps["required"]>;
+    message: InputSignal<DBSwitchProps["message"]>;
+    showMessage: InputSignal<DBSwitchProps["showMessage"]>;
+    validMessage: InputSignal<DBSwitchProps["validMessage"]>;
+    invalidMessage: InputSignal<DBSwitchProps["invalidMessage"]>;
+    checked: ModelSignal<DBSwitchProps["checked"]>;
+    visualAid: InputSignal<DBSwitchProps["visualAid"]>;
+    size: InputSignal<DBSwitchProps["size"]>;
+    showLabel: InputSignal<DBSwitchProps["showLabel"]>;
+    variant: InputSignal<DBSwitchProps["variant"]>;
+    showRequiredAsterisk: InputSignal<DBSwitchProps["showRequiredAsterisk"]>;
+    className: InputSignal<DBSwitchProps["className"]>;
+    value: InputSignal<DBSwitchProps["value"]>;
+    disabled: ModelSignal<DBSwitchProps["disabled"]>;
+    name: InputSignal<DBSwitchProps["name"]>;
+    iconLeading: InputSignal<DBSwitchProps["iconLeading"]>;
+    icon: InputSignal<DBSwitchProps["icon"]>;
+    iconTrailing: InputSignal<DBSwitchProps["iconTrailing"]>;
+    label: InputSignal<DBSwitchProps["label"]>;
+    messageIcon: InputSignal<DBSwitchProps["messageIcon"]>;
+    blur: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    focus: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _messageId: _angular_core.WritableSignal<string | undefined>;
+    _validMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessage: _angular_core.WritableSignal<string | undefined>;
+    _descByIds: _angular_core.WritableSignal<string | undefined>;
+    _voiceOverFallback: _angular_core.WritableSignal<string | undefined>;
+    hasValidState(): boolean;
+    handleValidation(): void;
+    handleChange(event: ChangeEvent<HTMLInputElement>): void;
+    handleBlur(event: InteractionEvent<HTMLInputElement>): void;
+    handleFocus(event: InteractionEvent<HTMLInputElement>): void;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBSwitch, "db-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; "validMessage": { "alias": "validMessage"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "visualAid": { "alias": "visualAid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "iconLeading": { "alias": "iconLeading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconTrailing": { "alias": "iconTrailing"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "messageIcon": { "alias": "messageIcon"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "disabled": "disabledChange"; "blur": "blur"; "focus": "focus"; }, never, ["*"], true, never>;
+}
+
+type DBTabItemDefaultProps = {
+    /**
+     * To control the component
+     */
+    checked?: boolean | string;
+    /**
+     * The disabled attribute can be set to keep a user from clicking on the tab-item.
+     */
+    disabled?: boolean | string;
+    /**
+     * The label of the tab-item, if you don't want to use children.
+     */
+    label?: string;
+    /**
+     * Define the text next to the icon specified via the icon Property to get hidden.
+     */
+    noText?: boolean | string;
+};
+type DBTabItemProps = GlobalProps & DBTabItemDefaultProps & IconProps & IconTrailingProps & IconLeadingProps & ShowIconLeadingProps & ShowIconTrailingProps & ActiveProps & ChangeEventProps<HTMLInputElement> & ShowIconProps & NameProps;
+type DBTabItemDefaultState = {
+    _selected: boolean;
+};
+type DBTabItemState = DBTabItemDefaultState & GlobalState & ChangeEventState<HTMLInputElement> & InitializedState & NameState;
+
+declare class DBTabItem implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    active: InputSignal<DBTabItemProps["active"]>;
+    name: InputSignal<DBTabItemProps["name"]>;
+    className: InputSignal<DBTabItemProps["className"]>;
+    id: InputSignal<DBTabItemProps["id"]>;
+    iconLeading: InputSignal<DBTabItemProps["iconLeading"]>;
+    icon: InputSignal<DBTabItemProps["icon"]>;
+    iconTrailing: InputSignal<DBTabItemProps["iconTrailing"]>;
+    showIconLeading: InputSignal<DBTabItemProps["showIconLeading"]>;
+    showIcon: InputSignal<DBTabItemProps["showIcon"]>;
+    showIconTrailing: InputSignal<DBTabItemProps["showIconTrailing"]>;
+    noText: InputSignal<DBTabItemProps["noText"]>;
+    disabled: ModelSignal<DBTabItemProps["disabled"]>;
+    checked: ModelSignal<DBTabItemProps["checked"]>;
+    label: InputSignal<DBTabItemProps["label"]>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _selected: _angular_core.WritableSignal<boolean>;
+    _name: _angular_core.WritableSignal<string | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    handleNameAttribute(): void;
+    handleChange(event: any): void;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTabItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTabItem, "db-tab-item", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "iconLeading": { "alias": "iconLeading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconTrailing": { "alias": "iconTrailing"; "required": false; "isSignal": true; }; "showIconLeading": { "alias": "showIconLeading"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "showIconTrailing": { "alias": "showIconTrailing"; "required": false; "isSignal": true; }; "noText": { "alias": "noText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "checked": "checkedChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+type DBTabListDefaultProps = {};
+type DBTabListProps = DBTabListDefaultProps & GlobalProps;
+type DBTabListDefaultState = {};
+type DBTabListState = DBTabListDefaultState & GlobalState;
+
+declare class DBTabList implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBTabListProps["id"]>;
+    className: InputSignal<DBTabListProps["className"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTabList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTabList, "db-tab-list", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type DBTabPanelDefaultProps = {
+    /**
+     * The content if you don't want to use children.
+     */
+    content?: string;
+};
+type DBTabPanelProps = DBTabPanelDefaultProps & GlobalProps;
+type DBTabPanelDefaultState = {};
+type DBTabPanelState = DBTabPanelDefaultState & GlobalState;
+
+declare class DBTabPanel implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    className: InputSignal<DBTabPanelProps["className"]>;
+    id: InputSignal<DBTabPanelProps["id"]>;
+    content: InputSignal<DBTabPanelProps["content"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTabPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTabPanel, "db-tab-panel", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const TabsBehaviorList: readonly ["scrollbar", "arrows"];
+type TabsBehaviorType = (typeof TabsBehaviorList)[number];
+declare const TabsInitialSelectedModeList: readonly ["auto", "manually"];
+type TabsInitialSelectedModeType = (typeof TabsInitialSelectedModeList)[number];
+type DBSimpleTabProps = DBTabItemProps & DBTabPanelProps;
+type DBTabsDefaultProps = {
+    /**
+     * Change amount of distance if you click on an arrow, only available with behavior="arrows"
+     */
+    arrowScrollDistance?: number | string;
+    /**
+     * Show a scrollbar or buttons with arrows to navigate for horizontal tabs with overflow visible
+     */
+    behavior?: TabsBehaviorType;
+    /**
+     * Default behavior is auto selecting the first tab, change selected tab by index
+     */
+    initialSelectedIndex?: number | string;
+    /**
+     * Default behavior is auto selecting the first tab, disable it with 'manually'
+     */
+    initialSelectedMode?: TabsInitialSelectedModeType;
+    /**
+     * The name of the tab bar, is required for grouping multiple tabs together. Will overwrite names from children.
+     */
+    name?: string;
+    /**
+     * Provide simple tabs with label + text as content
+     */
+    tabs?: DBSimpleTabProps[] | string;
+};
+type DBTabsEventProps = {
+    /**
+     * Informs the user if the current tab index has changed.
+     */
+    indexChange?: (index?: number) => void;
+    /**
+     * Informs the user if the current tab index has changed.
+     */
+    onIndexChange?: (index?: number) => void;
+    /**
+     * Informs the user if another tab has been selected.
+     */
+    onTabSelect?: (event?: InputEvent<HTMLElement>) => void;
+    /**
+     * Informs the user if another tab has been selected.
+     */
+    tabSelect?: (event?: InputEvent<HTMLElement>) => void;
+};
+type DBTabsProps = DBTabsDefaultProps & GlobalProps & OrientationProps & WidthProps & AlignmentProps & DBTabsEventProps;
+type DBTabsDefaultState = {
+    _name: string;
+    scrollContainer?: Element | null;
+    scroll: (left?: boolean) => void;
+    showScrollLeft?: boolean;
+    showScrollRight?: boolean;
+    evaluateScrollButtons: (tabList: Element) => void;
+    convertTabs: () => DBSimpleTabProps[];
+    initTabList: () => void;
+    initTabs: (init?: boolean) => void;
+    handleChange: (event: InputEvent<HTMLElement>) => void;
+    _resizeObserver?: ResizeObserver;
+};
+type DBTabsState = DBTabsDefaultState & GlobalState & InitializedState;
+
+declare class DBTabs implements AfterViewInit, OnDestroy {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    id: InputSignal<DBTabsProps["id"]>;
+    name: InputSignal<DBTabsProps["name"]>;
+    tabs: InputSignal<DBTabsProps["tabs"]>;
+    arrowScrollDistance: InputSignal<DBTabsProps["arrowScrollDistance"]>;
+    orientation: InputSignal<DBTabsProps["orientation"]>;
+    behavior: InputSignal<DBTabsProps["behavior"]>;
+    initialSelectedMode: InputSignal<DBTabsProps["initialSelectedMode"]>;
+    initialSelectedIndex: InputSignal<DBTabsProps["initialSelectedIndex"]>;
+    className: InputSignal<DBTabsProps["className"]>;
+    alignment: InputSignal<DBTabsProps["alignment"]>;
+    width: InputSignal<DBTabsProps["width"]>;
+    indexChange: _angular_core.OutputEmitterRef<number | void | undefined>;
+    tabSelect: _angular_core.OutputEmitterRef<void | Event | undefined>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _name: _angular_core.WritableSignal<string>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    showScrollLeft: _angular_core.WritableSignal<boolean | undefined>;
+    showScrollRight: _angular_core.WritableSignal<boolean | undefined>;
+    scrollContainer: _angular_core.WritableSignal<Element | null | undefined>;
+    _resizeObserver: _angular_core.WritableSignal<ResizeObserver | undefined>;
+    convertTabs(): any;
+    evaluateScrollButtons(tList: Element): void;
+    scroll(left?: boolean): void;
+    initTabList(): void;
+    initTabs(init?: boolean): void;
+    handleChange(event: InputEvent<HTMLElement>): void;
+    trackByTab0(index: number, tab: any): string;
+    trackByTab1(index: number, tab: any): string;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTabs, "db-tabs", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; "arrowScrollDistance": { "alias": "arrowScrollDistance"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; "initialSelectedMode": { "alias": "initialSelectedMode"; "required": false; "isSignal": true; }; "initialSelectedIndex": { "alias": "initialSelectedIndex"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "tabSelect": "tabSelect"; }, never, ["*"], true, never>;
+}
+
+declare const TagBehaviorList: readonly ["static", "removable"];
+type TagBehaviorType = (typeof TagBehaviorList)[number];
+type DBTagEventsProps = {
+    /**
+     * If "removeButton" attribute is set this function will be called when user clicks cancel button inside the tag.
+     */
+    onRemove?: (event?: ClickEvent<HTMLButtonElement> | void) => void;
+    /**
+     * If "removeButton" attribute is set this function will be called when user clicks cancel button inside the tag.
+     */
+    remove?: (event?: ClickEvent<HTMLButtonElement> | void) => void;
+};
+type DBTagDefaultProps = {
+    /**
+     *	Defines the behavior of the component:
+     *	- static: default behavior without remove button
+     *  - removable: add a remove button at the end of the tag
+     */
+    behavior?: TagBehaviorType | string;
+    /**
+     * Define the text next to the icon specified via the icon Property to get hidden.
+     */
+    noText?: boolean | string;
+    /**
+     * The removeButton attribute shows the cancel button.
+     */
+    removeButton?: string;
+    /**
+     * Enable/Disable icon for checkbox/radio inside tag.
+     */
+    showCheckState?: boolean | string;
+    /**
+     * Alternative for children to set content as property.
+     */
+    text?: string;
+    /**
+     * If "interactive" is set to true, you can pass a value to the underlying checkbox or radio input.
+     */
+    value?: string;
+};
+type DBTagProps = DBTagDefaultProps & GlobalProps & IconProps & SemanticProps & OverflowProps & EmphasisProps & ShowIconProps & ContentSlotProps & DBTagEventsProps;
+type DBTagDefaultState = {
+    getRemoveButtonText: () => string;
+    handleRemove: (event?: ClickEvent<HTMLButtonElement> | void) => void;
+};
+type DBTagState = DBTagDefaultState & GlobalState;
+
+declare class DBTag implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    removeButton: InputSignal<DBTagProps["removeButton"]>;
+    id: InputSignal<DBTagProps["id"]>;
+    className: InputSignal<DBTagProps["className"]>;
+    semantic: InputSignal<DBTagProps["semantic"]>;
+    emphasis: InputSignal<DBTagProps["emphasis"]>;
+    icon: InputSignal<DBTagProps["icon"]>;
+    showCheckState: InputSignal<DBTagProps["showCheckState"]>;
+    showIcon: InputSignal<DBTagProps["showIcon"]>;
+    noText: InputSignal<DBTagProps["noText"]>;
+    overflow: InputSignal<DBTagProps["overflow"]>;
+    text: InputSignal<DBTagProps["text"]>;
+    behavior: InputSignal<DBTagProps["behavior"]>;
+    remove: _angular_core.OutputEmitterRef<void | MouseEvent | undefined>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    handleRemove(event?: ClickEvent<HTMLButtonElement> | void): void;
+    getRemoveButtonText(): string | undefined;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTag, "db-tag", never, { "removeButton": { "alias": "removeButton"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "semantic": { "alias": "semantic"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showCheckState": { "alias": "showCheckState"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "noText": { "alias": "noText"; "required": false; "isSignal": true; }; "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "behavior": { "alias": "behavior"; "required": false; "isSignal": true; }; }, { "remove": "remove"; }, never, ["[content]", "*"], true, never>;
+}
+
+declare const TextareaResizeList: readonly ["none", "both", "horizontal", "vertical"];
+type TextareaResizeType = (typeof TextareaResizeList)[number];
+declare const TextareaWrapList: readonly ["hard", "soft", "off"];
+type TextareaWrapType = (typeof TextareaWrapList)[number];
+type DBTextareaDefaultProps = {
+    /**
+     * The visible width of the text control, in average character widths. If it is specified, it must be a positive integer
+     */
+    cols?: number | string;
+    /**
+     * In most browsers, textareas are resizable — you'll notice the drag handle in the right-hand corner, you can control it with this
+     */
+    resize?: TextareaResizeType;
+    /**
+     * Show/Hides drag handle in the right-hand corner - default: true
+     */
+    showResizer?: boolean | string;
+    /**
+     * The number of visible text lines for the control. If it is specified, it must be a positive integer
+     */
+    rows?: number | string;
+    /**
+     * Specifies whether the textarea is subject to spell checking by the underlying browser/OS
+     */
+    spellCheck?: boolean;
+    /**
+     * Indicates how the control should wrap the value for form submission.
+     */
+    wrap?: TextareaWrapType;
+};
+type DBTextareaProps = DBTextareaDefaultProps & ChangeEventProps<HTMLTextAreaElement> & InputEventProps<HTMLTextAreaElement> & FocusEventProps<HTMLTextAreaElement> & FormProps & GlobalProps & FormTextProps & FormMessageProps;
+type DBTextareaDefaultState = {};
+type DBTextareaState = DBTextareaDefaultState & ChangeEventState<HTMLTextAreaElement> & InputEventState<HTMLTextAreaElement> & FocusEventState<HTMLTextAreaElement> & FormState & GlobalState & FromValidState;
+
+declare class DBTextarea implements AfterViewInit, ControlValueAccessor {
+    private renderer;
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getHideProp: (show?: boolean | string) => any;
+    protected readonly DEFAULT_LABEL: string;
+    protected readonly getBoolean: (originBool?: boolean | string, propertyName?: string) => boolean | undefined;
+    protected readonly getNumber: (originNumber?: number | string, alternativeNumber?: number | string) => number | undefined;
+    protected readonly DEFAULT_PLACEHOLDER: string;
+    protected readonly DEFAULT_ROWS: number;
+    protected readonly stringPropVisible: (givenString?: string, showString?: boolean | string) => boolean;
+    protected readonly DEFAULT_VALID_MESSAGE: string;
+    id: InputSignal<DBTextareaProps["id"]>;
+    invalidMessage: InputSignal<DBTextareaProps["invalidMessage"]>;
+    message: InputSignal<DBTextareaProps["message"]>;
+    showMessage: InputSignal<DBTextareaProps["showMessage"]>;
+    value: ModelSignal<DBTextareaProps["value"]>;
+    validMessage: InputSignal<DBTextareaProps["validMessage"]>;
+    validation: InputSignal<DBTextareaProps["validation"]>;
+    required: InputSignal<DBTextareaProps["required"]>;
+    minLength: InputSignal<DBTextareaProps["minLength"]>;
+    maxLength: InputSignal<DBTextareaProps["maxLength"]>;
+    className: InputSignal<DBTextareaProps["className"]>;
+    variant: InputSignal<DBTextareaProps["variant"]>;
+    showRequiredAsterisk: InputSignal<DBTextareaProps["showRequiredAsterisk"]>;
+    showLabel: InputSignal<DBTextareaProps["showLabel"]>;
+    label: InputSignal<DBTextareaProps["label"]>;
+    fieldSizing: InputSignal<DBTextareaProps["fieldSizing"]>;
+    resize: InputSignal<DBTextareaProps["resize"]>;
+    showResizer: InputSignal<DBTextareaProps["showResizer"]>;
+    disabled: ModelSignal<DBTextareaProps["disabled"]>;
+    readOnly: InputSignal<DBTextareaProps["readOnly"]>;
+    readonly: InputSignal<DBTextareaProps["readonly"]>;
+    form: InputSignal<DBTextareaProps["form"]>;
+    maxlength: InputSignal<DBTextareaProps["maxlength"]>;
+    minlength: InputSignal<DBTextareaProps["minlength"]>;
+    name: InputSignal<DBTextareaProps["name"]>;
+    wrap: InputSignal<DBTextareaProps["wrap"]>;
+    spellCheck: InputSignal<DBTextareaProps["spellCheck"]>;
+    autocomplete: InputSignal<DBTextareaProps["autocomplete"]>;
+    ariaDescribedBy: InputSignal<DBTextareaProps["ariaDescribedBy"]>;
+    placeholder: InputSignal<DBTextareaProps["placeholder"]>;
+    rows: InputSignal<DBTextareaProps["rows"]>;
+    cols: InputSignal<DBTextareaProps["cols"]>;
+    messageIcon: InputSignal<DBTextareaProps["messageIcon"]>;
+    input: _angular_core.OutputEmitterRef<void | Event>;
+    change: _angular_core.OutputEmitterRef<void | Event>;
+    blur: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    focus: _angular_core.OutputEmitterRef<void | FocusEvent>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    _messageId: _angular_core.WritableSignal<string | undefined>;
+    _validMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessageId: _angular_core.WritableSignal<string | undefined>;
+    _invalidMessage: _angular_core.WritableSignal<string | undefined>;
+    _descByIds: _angular_core.WritableSignal<string | undefined>;
+    _value: _angular_core.WritableSignal<string | undefined>;
+    _voiceOverFallback: _angular_core.WritableSignal<string | undefined>;
+    hasValidState(): boolean;
+    handleValidation(): void;
+    handleInput(event: InputEvent<HTMLTextAreaElement>): void;
+    handleChange(event: ChangeEvent<HTMLTextAreaElement>): void;
+    handleBlur(event: InteractionEvent<HTMLTextAreaElement> | any): void;
+    handleFocus(event: InteractionEvent<HTMLTextAreaElement> | any): void;
+    constructor(renderer: Renderer2);
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    writeValue(value: any): void;
+    propagateChange(_: any): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTextarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTextarea, "db-textarea", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidMessage": { "alias": "invalidMessage"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showMessage": { "alias": "showMessage"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "validMessage": { "alias": "validMessage"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showRequiredAsterisk": { "alias": "showRequiredAsterisk"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fieldSizing": { "alias": "fieldSizing"; "required": false; "isSignal": true; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; "showResizer": { "alias": "showResizer"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "spellCheck": { "alias": "spellCheck"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "messageIcon": { "alias": "messageIcon"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; "input": "input"; "change": "change"; "blur": "blur"; "focus": "focus"; }, never, never, true, never>;
+}
+
+declare const TooltipVariantList: readonly ["description", "label"];
+type TooltipVariantType = (typeof TooltipVariantList)[number];
+type DBTooltipDefaultProps = {
+    /**
+     * Show/Hides arrow
+     */
+    showArrow?: boolean | string;
+    /**
+     * Change the behavior of the tooltip:
+     * - description: Adds `aria-describedby` to parent
+     * - label: Adds `aria-labelledby` to parent
+     */
+    variant?: TooltipVariantType;
+};
+type DBTooltipProps = DBTooltipDefaultProps & GlobalProps & EmphasisProps & PlacementProps & PopoverProps;
+type DBTooltipDefaultState = {
+    getParent: () => HTMLElement;
+};
+type DBTooltipState = DBTooltipDefaultState & GlobalState & ClickEventState<HTMLElement> & PopoverState & InitializedState & DocumentScrollState;
+
+declare class DBTooltip implements AfterViewInit {
+    protected readonly cls: (...args: ClassNameArg[]) => string;
+    protected readonly getBooleanAsString: (originBool?: boolean | string) => any;
+    id: InputSignal<DBTooltipProps["id"]>;
+    variant: InputSignal<DBTooltipProps["variant"]>;
+    placement: InputSignal<DBTooltipProps["placement"]>;
+    className: InputSignal<DBTooltipProps["className"]>;
+    emphasis: InputSignal<DBTooltipProps["emphasis"]>;
+    animation: InputSignal<DBTooltipProps["animation"]>;
+    delay: InputSignal<DBTooltipProps["delay"]>;
+    width: InputSignal<DBTooltipProps["width"]>;
+    showArrow: InputSignal<DBTooltipProps["showArrow"]>;
+    _ref: _angular_core.Signal<ElementRef<any> | undefined>;
+    _id: _angular_core.WritableSignal<string | undefined>;
+    initialized: _angular_core.WritableSignal<boolean>;
+    _documentScrollListenerCallbackId: _angular_core.WritableSignal<string | undefined>;
+    _observer: _angular_core.WritableSignal<IntersectionObserver | undefined>;
+    handleClick(event: ClickEvent<HTMLElement>): void;
+    handleEscape(event: any): void;
+    getParent(): any;
+    handleAutoPlacement(parent?: HTMLElement): void;
+    handleDocumentScroll(event: any, parent?: HTMLElement): void;
+    handleLeave(): void;
+    handleEnter(parent?: HTMLElement): void;
+    constructor();
+    /**
+     * Passes `aria-*`, `data-*` & `class` attributes to correct child. Used in angular and stencil.
+     * @param element  the ref for the component
+     * @param customElementSelector  the custom element like `my-component`
+     */
+    private enableAttributePassing;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DBTooltip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DBTooltip, "db-tooltip", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "showArrow": { "alias": "showArrow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const DEFAULT_ID: string;
+declare const DEFAULT_LABEL: string;
+declare const DEFAULT_PLACEHOLDER: string;
+declare const DEFAULT_MESSAGE: string;
+declare const DEFAULT_LABEL_ID_SUFFIX: string;
+declare const DEFAULT_SELECT_ID_SUFFIX: string;
+declare const DEFAULT_MESSAGE_ID_SUFFIX: string;
+declare const DEFAULT_VALID_MESSAGE_ID_SUFFIX: string;
+declare const DEFAULT_INVALID_MESSAGE_ID_SUFFIX: string;
+declare const DEFAULT_PLACEHOLDER_ID_SUFFIX: string;
+declare const DEFAULT_DATALIST_ID_SUFFIX: string;
+declare const DEFAULT_VALID_MESSAGE: string;
+declare const DEFAULT_INVALID_MESSAGE: string;
+declare const DEFAULT_REMOVE: string;
+declare const DEFAULT_BACK: string;
+declare const DEFAULT_SELECTED: string;
+declare const DEFAULT_BURGER_MENU: string;
+declare const DEFAULT_ICON: string;
+declare const DEFAULT_ROWS: number;
+declare const DEFAULT_CLOSE_BUTTON: string;
+declare const DENSITY_CONST: string;
+declare const COLOR_CONST: string;
+declare enum DENSITY {
+    'FUNCTIONAL' = "functional",
+    'REGULAR' = "regular",
+    'EXPRESSIVE' = "expressive"
+}
+declare const DENSITIES: DENSITY[];
+declare enum COLOR_SIMPLE {
+    'PRIMARY' = "primary"
+}
+declare enum COLOR {
+    'NEUTRAL_BG_LEVEL_1' = "neutral-bg-basic-level-1",
+    'NEUTRAL_BG_LEVEL_2' = "neutral-bg-basic-level-2",
+    'NEUTRAL_BG_LEVEL_3' = "neutral-bg-basic-level-3",
+    'NEUTRAL_BG_TRANSPARENT_SEMI' = "neutral-bg-basic-transparent-semi",
+    'NEUTRAL_BG_TRANSPARENT_FULL' = "neutral-bg-basic-transparent-full",
+    'BRAND_BG_LEVEL_1' = "brand-bg-basic-level-1",
+    'BRAND_BG_LEVEL_2' = "brand-bg-basic-level-2",
+    'BRAND_BG_LEVEL_3' = "brand-bg-basic-level-3",
+    'BRAND_BG_TRANSPARENT_SEMI' = "brand-bg-basic-transparent-semi",
+    'BRAND_BG_TRANSPARENT_FULL' = "brand-bg-basic-transparent-full",
+    'SUCCESSFUL_BG_LEVEL_1' = "successful-bg-basic-level-1",
+    'SUCCESSFUL_BG_LEVEL_2' = "successful-bg-basic-level-2",
+    'SUCCESSFUL_BG_LEVEL_3' = "successful-bg-basic-level-3",
+    'SUCCESSFUL_BG_TRANSPARENT_SEMI' = "successful-bg-basic-transparent-semi",
+    'SUCCESSFUL_BG_TRANSPARENT_FULL' = "successful-bg-basic-transparent-full",
+    'CRITICAL_BG_LEVEL_1' = "critical-bg-basic-level-1",
+    'CRITICAL_BG_LEVEL_2' = "critical-bg-basic-level-2",
+    'CRITICAL_BG_LEVEL_3' = "critical-bg-basic-level-3",
+    'CRITICAL_BG_TRANSPARENT_SEMI' = "critical-bg-basic-transparent-semi",
+    'CRITICAL_BG_TRANSPARENT_Full' = "critical-bg-basic-transparent-full",
+    'WARNING_BG_LEVEL_1' = "warning-bg-basic-level-1",
+    'WARNING_BG_LEVEL_2' = "warning-bg-basic-level-2",
+    'WARNING_BG_LEVEL_3' = "warning-bg-basic-level-3",
+    'WARNING_BG_TRANSPARENT_SEMI' = "warning-bg-basic-transparent-semi",
+    'WARNING_BG_TRANSPARENT_FULL' = "warning-bg-basic-transparent-full",
+    'INFORMATIONAL_BG_LEVEL_1' = "informational-bg-basic-level-1",
+    'INFORMATIONAL_BG_LEVEL_2' = "informational-bg-basic-level-2",
+    'INFORMATIONAL_BG_LEVEL_3' = "informational-bg-basic-level-3",
+    'INFORMATIONAL_BG_TRANSPARENT_SEMI' = "informational-bg-basic-transparent-semi",
+    'INFORMATIONAL_BG_TRANSPARENT_FULL' = "informational-bg-basic-transparent-full"
+}
+declare const COLORS: COLOR[];
+declare const COLORS_SIMPLE: COLOR_SIMPLE[];
+declare enum SEMANTIC {
+    'CRITICAL' = "critical",
+    'INFORMATIONAL' = "informational",
+    'WARNING' = "warning",
+    'SUCCESSFUL' = "successful"
+}
+declare const SEMANTICS: SEMANTIC[];
+declare const DEFAULT_VIEWPORT: {
+    width: number;
+    height: number;
+};
+declare const DESKTOP_VIEWPORT: {
+    width: number;
+    height: number;
+};
+/**
+ * Use those viewports if your component has a css media-query otherwise use the DEFAULT_VIEWPORT
+ */
+declare const TESTING_VIEWPORTS: {
+    width: number;
+    height: number;
+    name: string;
+}[];
+
+declare class DocumentClickListener {
+    private static callbacks;
+    private static _instance;
+    private static runCallbacks;
+    constructor();
+    addCallback(callback: (event: any) => void): string;
+    removeCallback(id: string): void;
+}
+
+declare class DocumentScrollListener {
+    private static callbacks;
+    private static _instance;
+    private static runCallbacks;
+    private ticking;
+    constructor();
+    addCallback(callback: (event: any) => void): string;
+    removeCallback(id: string): void;
+}
+
+interface DBDataOutsidePair {
+    vx?: 'left' | 'right';
+    vy?: 'top' | 'bottom';
+}
+declare const handleDataOutside: (el: HTMLElement) => DBDataOutsidePair;
+declare const handleFixedDropdown: (element: HTMLElement, parent: HTMLElement, placement: string) => void;
+declare const getFloatingProps: (element: HTMLElement, parent: HTMLElement, placement: string) => {
+    top: number;
+    bottom: number;
+    right: number;
+    height: number;
+    width: number;
+    left: number;
+    childHeight: number;
+    childWidth: number;
+    correctedPlacement: string;
+    innerWidth: number;
+    innerHeight: number;
+};
+declare const handleFixedPopover: (element: HTMLElement, parent: HTMLElement, placement: string) => void;
+
+export { AccordionBehaviorList, AccordionVariantList, AlignmentList, AutoCompleteList, BadgePlacementList, ButtonTypeList, ButtonVariantList, COLOR, COLORS, COLORS_SIMPLE, COLOR_CONST, COLOR_SIMPLE, CardBehaviorList, CardElevationLevelList, CustomSelectDropdownWidthList, CustomSelectListItemTypeList, DBAccordion, DBAccordionItem, DBBadge, DBBrand, DBButton, DBCard, DBCheckbox, DBCustomSelect, DBCustomSelectDropdown, DBCustomSelectFormField, DBCustomSelectList, DBCustomSelectListItem, DBDivider, DBDrawer, DBHeader, DBIcon, DBInfotext, DBInput, DBLink, DBNavigation, DBNavigationItem, DBNotification, DBPage, DBPopover, DBRadio, DBSection, DBSelect, DBStack, DBSwitch, DBTabItem, DBTabList, DBTabPanel, DBTabs, DBTag, DBTextarea, DBTooltip, DEFAULT_BACK, DEFAULT_BURGER_MENU, DEFAULT_CLOSE_BUTTON, DEFAULT_DATALIST_ID_SUFFIX, DEFAULT_ICON, DEFAULT_ID, DEFAULT_INVALID_MESSAGE, DEFAULT_INVALID_MESSAGE_ID_SUFFIX, DEFAULT_LABEL, DEFAULT_LABEL_ID_SUFFIX, DEFAULT_MESSAGE, DEFAULT_MESSAGE_ID_SUFFIX, DEFAULT_PLACEHOLDER, DEFAULT_PLACEHOLDER_ID_SUFFIX, DEFAULT_REMOVE, DEFAULT_ROWS, DEFAULT_SELECTED, DEFAULT_SELECT_ID_SUFFIX, DEFAULT_VALID_MESSAGE, DEFAULT_VALID_MESSAGE_ID_SUFFIX, DEFAULT_VIEWPORT, DENSITIES, DENSITY, DENSITY_CONST, DESKTOP_VIEWPORT, DividerMarginList, DividerVariantList, DocumentClickListener, DocumentScrollListener, DrawerBackdropList, DrawerDirectionList, DrawerPositionList, DrawerVariantList, EmphasisList, FieldSizingList, GapSpacingList, IconWeightList, InputTypeList, LabelVariantHorizontalList, LabelVariantList, LinkContentList, LinkReferrerPolicyList, LinkSizeList, LinkTargetList, LinkVariantList, MarginList, MaxWidthList, MetaNavigationDirective, NavigationContentDirective, NavigationDirective, NavigationItemSafeTriangle, NotificationAriaLiveList, NotificationLinkVariantList, NotificationVariantList, OrientationList, PageDocumentOverflowList, PageVariantList, PlacementHorizontalList, PlacementList, PlacementVerticalList, PopoverDelayList, PopoverWidthList, SEMANTIC, SEMANTICS, SecondaryActionDirective, SelectedTypeList, SemanticList, SizeList, SpacingList, StackAlignmentList, StackDirectionList, StackJustifyContentList, StackVariantList, TESTING_VIEWPORTS, TabsBehaviorList, TabsInitialSelectedModeList, TagBehaviorList, TextareaResizeList, TextareaWrapList, TooltipVariantList, ValidationList, WidthList, addAttributeToChildren, cls, delay, getBoolean, getBooleanAsString, getFloatingProps, getHideProp, getInputValue, getNumber, getOptionKey, getSearchInput, handleDataOutside, handleFixedDropdown, handleFixedPopover, hasVoiceOver, isArrayOfStrings, isEventTargetNavigationItem, isIOSSafari, isKeyboardEvent, stringPropVisible, uuid };
+export type { AccordionBehaviorType, AccordionVariantType, ActiveProps, AlignmentProps, AlignmentType, AriaControlsProps, AutoCompleteType, BadgePlacementType, BaseFormProps, ButtonTypeType, ButtonVariantType, CardBehaviorType, CardElevationLevelType, ChangeEvent, ChangeEventProps, ChangeEventState, ClassNameArg, ClickEvent, ClickEventProps, ClickEventState, CloseEventProps, CloseEventState, ContainerWidthProps, ContentSlotProps, CustomFormProps, CustomSelectDropdownWidthType, CustomSelectListItemTypeType, CustomSelectOptionType, DBAccordionDefaultProps, DBAccordionDefaultState, DBAccordionItemDefaultProps, DBAccordionItemDefaultState, DBAccordionItemProps, DBAccordionItemState, DBAccordionProps, DBAccordionState, DBBadgeDefaultProps, DBBadgeDefaultState, DBBadgeProps, DBBadgeState, DBBrandDefaultProps, DBBrandDefaultState, DBBrandProps, DBBrandState, DBButtonDefaultProps, DBButtonDefaultState, DBButtonProps, DBButtonState, DBCardDefaultProps, DBCardDefaultState, DBCardProps, DBCardState, DBCheckboxDefaultProps, DBCheckboxDefaultState, DBCheckboxProps, DBCheckboxState, DBCustomSelectDefaultProps, DBCustomSelectDefaultState, DBCustomSelectDropdownDefaultProps, DBCustomSelectDropdownDefaultState, DBCustomSelectDropdownProps, DBCustomSelectDropdownState, DBCustomSelectEvents, DBCustomSelectFormFieldDefaultProps, DBCustomSelectFormFieldDefaultState, DBCustomSelectFormFieldProps, DBCustomSelectFormFieldState, DBCustomSelectListDefaultProps, DBCustomSelectListDefaultState, DBCustomSelectListItemDefaultProps, DBCustomSelectListItemDefaultState, DBCustomSelectListItemExtraProps, DBCustomSelectListItemProps, DBCustomSelectListItemState, DBCustomSelectListProps, DBCustomSelectListState, DBCustomSelectProps, DBCustomSelectState, DBDataOutsidePair, DBDividerDefaultProps, DBDividerDefaultState, DBDividerProps, DBDividerState, DBDrawerDefaultProps, DBDrawerDefaultState, DBDrawerProps, DBDrawerState, DBHeaderDefaultProps, DBHeaderDefaultState, DBHeaderProps, DBHeaderState, DBIconDefaultProps, DBIconDefaultState, DBIconProps, DBIconState, DBInfotextDefaultProps, DBInfotextDefaultState, DBInfotextProps, DBInfotextState, DBInputDefaultProps, DBInputDefaultState, DBInputProps, DBInputState, DBLinkDefaultProps, DBLinkDefaultState, DBLinkProps, DBLinkState, DBNavigationDefaultProps, DBNavigationDefaultState, DBNavigationItemDefaultProps, DBNavigationItemDefaultState, DBNavigationItemProps, DBNavigationItemState, DBNavigationProps, DBNavigationState, DBNotificationDefaultProps, DBNotificationDefaultState, DBNotificationProps, DBNotificationState, DBPageDefaultProps, DBPageDefaultState, DBPageProps, DBPageState, DBPopoverDefaultProps, DBPopoverDefaultState, DBPopoverProps, DBPopoverState, DBRadioDefaultProps, DBRadioDefaultState, DBRadioProps, DBRadioState, DBSectionDefaultProps, DBSectionDefaultState, DBSectionProps, DBSectionState, DBSelectDefaultProps, DBSelectDefaultState, DBSelectOptionType, DBSelectProps, DBSelectState, DBSimpleTabProps, DBStackDefaultProps, DBStackDefaultState, DBStackProps, DBStackState, DBSwitchDefaultProps, DBSwitchDefaultState, DBSwitchProps, DBSwitchState, DBTabItemDefaultProps, DBTabItemDefaultState, DBTabItemProps, DBTabItemState, DBTabListDefaultProps, DBTabListDefaultState, DBTabListProps, DBTabListState, DBTabPanelDefaultProps, DBTabPanelDefaultState, DBTabPanelProps, DBTabPanelState, DBTabsDefaultProps, DBTabsDefaultState, DBTabsEventProps, DBTabsProps, DBTabsState, DBTagDefaultProps, DBTagDefaultState, DBTagEventsProps, DBTagProps, DBTagState, DBTextareaDefaultProps, DBTextareaDefaultState, DBTextareaProps, DBTextareaState, DBTooltipDefaultProps, DBTooltipDefaultState, DBTooltipProps, DBTooltipState, DividerMarginType, DividerVariantType, DocumentScrollState, DrawerBackdropType, DrawerDirectionType, DrawerPositionType, DrawerVariantType, EmphasisProps, EmphasisType, FieldSizingType, FocusEventProps, FocusEventState, FormCheckProps, FormMessageProps, FormProps, FormSizeProps, FormState, FormTextProps, FromValidState, GapProps, GapSpacingProps, GapSpacingType, GeneralEvent, GeneralKeyboardEvent, GlobalProps, GlobalState, IconLeadingProps, IconProps, IconTrailingProps, IconWeightType, InitializedState, InnerCloseButtonProps, InputEvent, InputEventProps, InputEventState, InputTypeType, InteractionEvent, LabelVariantHorizontalType, LabelVariantType, LinkContentType, LinkProps, LinkReferrerPolicyType, LinkSizeType, LinkTargetType, LinkVariantType, MarginProps, MarginType, MaxWidthType, NameProps, NameState, NavigationBackButtonProps, NavigationBehaviorState, NotificationAriaLiveType, NotificationLinkVariantType, NotificationVariantType, OrientationProps, OrientationType, OverflowProps, PageDocumentOverflowType, PageVariantType, PlacementHorizontalType, PlacementProps, PlacementType, PlacementVerticalType, PopoverDelayType, PopoverProps, PopoverState, PopoverWidthType, RequiredProps, SelectedTypeType, SemanticProps, SemanticType, ShowIconLeadingProps, ShowIconProps, ShowIconTrailingProps, ShowLabelProps, SizeProps, SizeType, SpacingProps, SpacingType, StackAlignmentType, StackDirectionType, StackJustifyContentType, StackVariantType, TabsBehaviorType, TabsInitialSelectedModeType, TagBehaviorType, TextProps, TextareaResizeType, TextareaWrapType, ToggleEventProps, ToggleEventState, TooltipVariantType, TriangleData, ValidationType, ValueLabelType, ValueProps, WidthProps, WidthType, WrapProps };