@db-ux/v-core-components 1.0.0-test-13b991d

package/dist/components/section/section.vue.d.ts

@@ -0,0 +1,18 @@
+import { DBSectionProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBSectionProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DBSectionProps> & Readonly<{}>, {
+    children: any;
+    className: string;
+    id: string;
+    width: "medium" | "small" | "large" | "full";
+    spacing: "medium" | "small" | "large" | "none";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLElement;
+}, HTMLElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/select/index.d.ts

@@ -0,0 +1 @@
+export { default as DBSelect } from './select.vue';

package/dist/components/select/model.d.ts

@@ -0,0 +1,43 @@
+import { ChangeEventProps, ChangeEventState, ClickEventProps, ClickEventState, FocusEventProps, FocusEventState, FormMessageProps, FormProps, FormState, GlobalProps, GlobalState, IconProps, InitializedState, InputEventProps, InputEventState, ShowIconProps } from '../../shared/model';
+export type DBSelectDefaultProps = {
+    /**
+     * The description attribute will add a paragraph below the select.
+     */
+    description?: string;
+    /**
+     * If you don't/can't use children/slots you can pass in the options as an array.
+     */
+    options?: DBSelectOptionType[];
+};
+export 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;
+};
+export type DBSelectProps = DBSelectDefaultProps & GlobalProps & ClickEventProps<HTMLSelectElement> & ChangeEventProps<HTMLSelectElement> & FocusEventProps<HTMLSelectElement> & InputEventProps<HTMLSelectElement> & FormProps & IconProps & FormMessageProps & ShowIconProps;
+export type DBSelectDefaultState = {
+    _placeholderId: string;
+    getOptionLabel: (option: DBSelectOptionType) => string;
+};
+export type DBSelectState = DBSelectDefaultState & GlobalState & ClickEventState<HTMLSelectElement> & ChangeEventState<HTMLSelectElement> & FocusEventState<HTMLSelectElement> & InputEventState<HTMLSelectElement> & FormState & InitializedState;

package/dist/components/select/select.vue.d.ts

@@ -0,0 +1,47 @@
+import { DBSelectOptionType, DBSelectProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<DBSelectProps> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string;
+    disabled: boolean;
+    label: string;
+    value: any;
+    variant: "above" | "floating";
+    children: any;
+    className: string;
+    id: string;
+    onClick: (event: MouseEvent) => void;
+    icon: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    showIcon: boolean;
+    blur: (event: FocusEvent) => void;
+    change: (event: Event) => void;
+    focus: (event: FocusEvent) => void;
+    input: (event: Event) => void;
+    onFocus: (event: FocusEvent) => void;
+    onBlur: (event: FocusEvent) => void;
+    onChange: (event: Event) => void;
+    onInput: (event: Event) => void;
+    validation: "invalid" | "valid" | "no-validation";
+    required: boolean;
+    showLabel: boolean;
+    placeholder: string;
+    message: string;
+    validMessage: string;
+    invalidMessage: string;
+    messageIcon: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    autocomplete: string;
+    showMessage: boolean;
+    options: DBSelectOptionType[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLSelectElement;
+}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/stack/index.d.ts

@@ -0,0 +1 @@
+export { default as DBStack } from './stack.vue';

package/dist/components/stack/model.d.ts

@@ -0,0 +1,34 @@
+import { GapSpacingProps, GlobalProps, GlobalState } from '../../shared/model';
+export declare const StackVariantList: readonly ["simple", "divider"];
+export type StackVariantType = (typeof StackVariantList)[number];
+export declare const StackDirectionList: readonly ["row", "column"];
+export type StackDirectionType = (typeof StackDirectionList)[number];
+export declare const StackAlignmentList: readonly ["stretch", "start", "end", "center"];
+export type StackAlignmentType = (typeof StackAlignmentList)[number];
+export declare const StackJustifyContentList: readonly ["space-between", "start", "end", "center"];
+export type StackJustifyContentType = (typeof StackJustifyContentList)[number];
+export 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;
+    /**
+     * Represents css align-items
+     */
+    alignment?: StackAlignmentType;
+    /**
+     * Represents css justify-content
+     */
+    justifyContent?: StackJustifyContentType;
+};
+export type DBStackProps = DBStackDefaultProps & GlobalProps & GapSpacingProps;
+export type DBStackDefaultState = {};
+export type DBStackState = DBStackDefaultState & GlobalState;

package/dist/components/stack/stack.vue.d.ts

@@ -0,0 +1,22 @@
+import { DBStackProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBStackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DBStackProps> & Readonly<{}>, {
+    variant: "divider" | "simple";
+    children: any;
+    className: string;
+    id: string;
+    direction: "row" | "column";
+    wrap: boolean;
+    gap: "medium" | "small" | "large" | "none" | "3x-large" | "2x-large" | "x-large" | "x-small" | "2x-small" | "3x-small";
+    alignment: "start" | "center" | "stretch" | "end";
+    justifyContent: "start" | "center" | "end" | "space-between";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLDivElement;
+}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/switch/index.d.ts

@@ -0,0 +1 @@
+export { default as DBSwitch } from './switch.vue';

package/dist/components/switch/model.d.ts

@@ -0,0 +1,12 @@
+import { ChangeEventProps, ChangeEventState, EmphasisProps, FocusEventProps, FocusEventState, FormCheckProps, FormProps, FormState, GlobalProps, GlobalState, IconAfterProps, IconProps, InitializedState, SizeProps } from '../../shared/model';
+export type DBSwitchDefaultProps = {
+    /**
+     * Add additional icons to indicate active/inactive state.
+     */
+    visualAid?: boolean;
+};
+export type DBSwitchProps = DBSwitchDefaultProps & GlobalProps & ChangeEventProps<HTMLInputElement> & FocusEventProps<HTMLInputElement> & FormProps & FormCheckProps & EmphasisProps & SizeProps & IconProps & IconAfterProps;
+export type DBSwitchDefaultState = {
+    _checked: boolean;
+};
+export type DBSwitchState = DBSwitchDefaultState & GlobalState & ChangeEventState<HTMLInputElement> & FocusEventState<HTMLInputElement> & FormState & InitializedState;

package/dist/components/switch/switch.vue.d.ts

@@ -0,0 +1,39 @@
+import { DBSwitchProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:checked": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<DBSwitchProps> & Readonly<{
+    "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string;
+    disabled: boolean;
+    label: string;
+    children: any;
+    className: string;
+    describedbyid: string;
+    id: string;
+    icon: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    size: "medium" | "small";
+    blur: (event: FocusEvent) => void;
+    change: (event: Event) => void;
+    focus: (event: FocusEvent) => void;
+    onFocus: (event: FocusEvent) => void;
+    onBlur: (event: FocusEvent) => void;
+    onChange: (event: Event) => void;
+    emphasis: "weak" | "strong";
+    validation: "invalid" | "valid" | "no-validation";
+    required: boolean;
+    showLabel: boolean;
+    checked: boolean;
+    iconAfter: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    visualAid: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLInputElement;
+}, HTMLLabelElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tab-item/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTabItem } from './tab-item.vue';

package/dist/components/tab-item/model.d.ts

@@ -0,0 +1,24 @@
+import { ActiveProps, AriaControlsProps, ChangeEventProps, ChangeEventState, GlobalProps, GlobalState, IconAfterProps, IconProps, InitializedState, ShowIconProps } from '../../shared/model';
+export type DBTabItemDefaultProps = {
+    /**
+     * To control the component
+     */
+    checked?: boolean;
+    /**
+     * The disabled attribute can be set to keep a user from clicking on the tab-item.
+     */
+    disabled?: boolean;
+    /**
+     * 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;
+};
+export type DBTabItemProps = GlobalProps & DBTabItemDefaultProps & IconProps & IconAfterProps & ActiveProps & AriaControlsProps & ChangeEventProps<HTMLInputElement> & ShowIconProps;
+export type DBTabItemDefaultState = {
+    _selected: boolean;
+};
+export type DBTabItemState = DBTabItemDefaultState & GlobalState & ChangeEventState<HTMLInputElement> & InitializedState;

package/dist/components/tab-item/tab-item.vue.d.ts

@@ -0,0 +1,31 @@
+import type { DBTabItemProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBTabItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:checked": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<DBTabItemProps> & Readonly<{
+    "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    noText: boolean;
+    label: string;
+    children: any;
+    className: string;
+    id: string;
+    icon: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    showIcon: boolean;
+    change: (event: Event) => void;
+    onChange: (event: Event) => void;
+    checked: boolean;
+    iconAfter: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    active: boolean;
+    controls: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLInputElement;
+}, HTMLLIElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tab-list/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTabList } from './tab-list.vue';

package/dist/components/tab-list/model.d.ts

@@ -0,0 +1,5 @@
+import { GlobalProps, GlobalState } from '../../shared/model';
+export type DBTabListDefaultProps = {};
+export type DBTabListProps = DBTabListDefaultProps & GlobalProps;
+export type DBTabListDefaultState = {};
+export type DBTabListState = DBTabListDefaultState & GlobalState;

package/dist/components/tab-list/tab-list.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("../..").GlobalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("../..").GlobalProps> & Readonly<{}>, {
+    children: any;
+    className: string;
+    id: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLDivElement;
+}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tab-panel/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTabPanel } from './tab-panel.vue';

package/dist/components/tab-panel/model.d.ts

@@ -0,0 +1,10 @@
+import { AriaLabelledByProps, GlobalProps, GlobalState } from '../../shared/model';
+export type DBTabPanelDefaultProps = {
+    /**
+     * The content if you don't want to use children.
+     */
+    content?: string;
+};
+export type DBTabPanelProps = DBTabPanelDefaultProps & GlobalProps & AriaLabelledByProps;
+export type DBTabPanelDefaultState = {};
+export type DBTabPanelState = DBTabPanelDefaultState & GlobalState;

package/dist/components/tab-panel/tab-panel.vue.d.ts

@@ -0,0 +1,18 @@
+import { DBTabPanelProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBTabPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DBTabPanelProps> & Readonly<{}>, {
+    content: string;
+    children: any;
+    className: string;
+    id: string;
+    labelledBy: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLElement;
+}, HTMLElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tabs/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTabs } from './tabs.vue';

package/dist/components/tabs/model.d.ts

@@ -0,0 +1,47 @@
+import { AlignmentProps, GlobalProps, GlobalState, InitializedState, OrientationProps, WidthProps } from '../../shared/model';
+import { DBTabItemProps } from '../tab-item/model';
+import { DBTabPanelProps } from '../tab-panel/model';
+export declare const TabsBehaviorList: readonly ["scrollbar", "arrows"];
+export type TabsBehaviorType = (typeof TabsBehaviorList)[number];
+export declare const TabsInitialSelectedModeList: readonly ["auto", "manually"];
+export type TabsInitialSelectedModeType = (typeof TabsInitialSelectedModeList)[number];
+export type DBSimpleTabProps = DBTabItemProps & DBTabPanelProps;
+export type DBTabsDefaultProps = {
+    /**
+     * Change amount of distance if you click on an arrow, only available with behavior="arrows"
+     */
+    arrowScrollDistance?: number;
+    /**
+     * 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;
+    /**
+     * 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;
+};
+export type DBTabsProps = DBTabsDefaultProps & GlobalProps & OrientationProps & WidthProps & AlignmentProps;
+export type DBTabsDefaultState = {
+    _name: string;
+    scrollContainer?: Element | null;
+    scroll: (left?: boolean) => void;
+    showScrollLeft?: boolean;
+    showScrollRight?: boolean;
+    evaluateScrollButtons: (tabList: Element) => void;
+    convertTabs: (tabs?: unknown[] | string | undefined) => DBSimpleTabProps[];
+    initTabList: () => void;
+    initTabs: (init?: boolean) => void;
+};
+export type DBTabsState = DBTabsDefaultState & GlobalState & InitializedState;

package/dist/components/tabs/tabs.vue.d.ts

@@ -0,0 +1,25 @@
+import { DBSimpleTabProps, DBTabsProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBTabsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DBTabsProps> & Readonly<{}>, {
+    name: string;
+    children: any;
+    className: string;
+    id: string;
+    width: "full" | "auto";
+    behavior: "scrollbar" | "arrows";
+    arrowScrollDistance: number;
+    initialSelectedIndex: number;
+    initialSelectedMode: "auto" | "manually";
+    tabs: string | DBSimpleTabProps[];
+    orientation: "horizontal" | "vertical";
+    alignment: "start" | "center";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLDivElement;
+}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tag/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTag } from './tag.vue';

package/dist/components/tag/model.d.ts

@@ -0,0 +1,45 @@
+import { ContentSlotProps, GlobalProps, GlobalState, IconProps, InitializedState, OverflowProps, SemanticProps, ShowIconProps, TagEmphasisProps } from '../../shared/model';
+export declare const TagBehaviorList: readonly ["static", "removable"];
+export type TagBehaviorType = (typeof TagBehaviorList)[number];
+export 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;
+    /**
+     * @deprecated Disable tag
+     */
+    disabled?: boolean;
+    /**
+     * Define the text next to the icon specified via the icon Property to get hidden.
+     */
+    noText?: boolean;
+    /**
+     * If "removeButton" attribute is set this function will be called when user clicks cancel button inside the tag.
+     */
+    onRemove?: () => void;
+    /**
+     * The removeButton attribute shows the cancel button.
+     */
+    removeButton?: string;
+    /**
+     * Enable/Disable icon for checkbox/radio inside tag.
+     */
+    showCheckState?: boolean;
+    /**
+     * 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;
+};
+export type DBTagProps = DBTagDefaultProps & GlobalProps & IconProps & SemanticProps & OverflowProps & TagEmphasisProps & ShowIconProps & ContentSlotProps;
+export type DBTagDefaultState = {
+    getRemoveButtonText: () => string;
+    handleRemove: () => void;
+};
+export type DBTagState = DBTagDefaultState & GlobalState & InitializedState;

package/dist/components/tag/tag.vue.d.ts

@@ -0,0 +1,29 @@
+import { DBTagProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBTagProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DBTagProps> & Readonly<{}>, {
+    disabled: boolean;
+    noText: boolean;
+    children: any;
+    className: string;
+    id: string;
+    icon: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    showIcon: boolean;
+    text: string;
+    semantic: "adaptive" | "neutral" | "critical" | "informational" | "warning" | "successful";
+    emphasis: "weak" | "strong" | "origin";
+    behavior: string;
+    onRemove: () => void;
+    removeButton: string;
+    showCheckState: boolean;
+    overflow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLDivElement;
+}, HTMLDivElement>, {
+    content?(_: {}): any;
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/textarea/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTextarea } from './textarea.vue';

package/dist/components/textarea/model.d.ts

@@ -0,0 +1,30 @@
+import { ChangeEventProps, ChangeEventState, FocusEventProps, FocusEventState, FormMessageProps, FormProps, FormState, FormTextProps, GlobalProps, GlobalState, InputEventProps, InputEventState } from '../../shared/model';
+export declare const TextareaResizeList: readonly ["none", "both", "horizontal", "vertical"];
+export type TextareaResizeType = (typeof TextareaResizeList)[number];
+export declare const TextareaWrapList: readonly ["hard", "soft", "off"];
+export type TextareaWrapType = (typeof TextareaWrapList)[number];
+export 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;
+    /**
+     * 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;
+    /**
+     * The number of visible text lines for the control. If it is specified, it must be a positive integer
+     */
+    rows?: number;
+    /**
+     * 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;
+};
+export type DBTextareaProps = DBTextareaDefaultProps & ChangeEventProps<HTMLTextAreaElement> & InputEventProps<HTMLTextAreaElement> & FocusEventProps<HTMLTextAreaElement> & FormProps & GlobalProps & FormTextProps & FormMessageProps;
+export type DBTextareaDefaultState = {};
+export type DBTextareaState = DBTextareaDefaultState & ChangeEventState<HTMLTextAreaElement> & InputEventState<HTMLTextAreaElement> & FocusEventState<HTMLTextAreaElement> & FormState & GlobalState;

package/dist/components/textarea/textarea.vue.d.ts

@@ -0,0 +1,44 @@
+import { DBTextareaProps } from "./model";
+declare const _default: import("vue").DefineComponent<DBTextareaProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<DBTextareaProps> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string;
+    spellCheck: boolean;
+    disabled: boolean;
+    label: string;
+    value: any;
+    variant: "above" | "floating";
+    className: string;
+    id: string;
+    blur: (event: FocusEvent) => void;
+    change: (event: Event) => void;
+    focus: (event: FocusEvent) => void;
+    input: (event: Event) => void;
+    resize: "none" | "horizontal" | "vertical" | "both";
+    form: string;
+    onFocus: (event: FocusEvent) => void;
+    onBlur: (event: FocusEvent) => void;
+    onChange: (event: Event) => void;
+    onInput: (event: Event) => void;
+    validation: "invalid" | "valid" | "no-validation";
+    required: boolean;
+    showLabel: boolean;
+    placeholder: string;
+    message: string;
+    validMessage: string;
+    invalidMessage: string;
+    messageIcon: import("@db-ux/core-foundations").BaseIconTypes | import("@db-ux/core-foundations").LooseAutocomplete;
+    autocomplete: string;
+    showMessage: boolean;
+    maxLength: number;
+    minLength: number;
+    readOnly: boolean;
+    cols: number;
+    rows: number;
+    wrap: "off" | "hard" | "soft";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1 @@
+export { default as DBTooltip } from './tooltip.vue';

package/dist/components/tooltip/model.d.ts

@@ -0,0 +1,7 @@
+import { ClickEventState, EmphasisProps, GlobalProps, GlobalState, InitializedState, PlacementProps, PopoverProps, PopoverState } from '../../shared/model';
+export type DBTooltipDefaultProps = {
+    showArrow?: boolean;
+};
+export type DBTooltipProps = DBTooltipDefaultProps & GlobalProps & EmphasisProps & PlacementProps & PopoverProps;
+export type DBTooltipDefaultState = {};
+export type DBTooltipState = DBTooltipDefaultState & GlobalState & ClickEventState<HTMLElement> & PopoverState & InitializedState;

package/dist/components/tooltip/tooltip.vue.d.ts

@@ -0,0 +1,22 @@
+import { DBTooltipProps } from "./model";
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<DBTooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DBTooltipProps> & Readonly<{}>, {
+    children: any;
+    className: string;
+    id: string;
+    width: "auto" | "fixed";
+    delay: "none" | "slow" | "fast";
+    animation: boolean;
+    placement: "left" | "right" | "top" | "bottom" | "left-start" | "left-end" | "right-start" | "right-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end";
+    emphasis: "weak" | "strong";
+    showArrow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    _ref: HTMLElement;
+}, HTMLElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};