@porsche-design-system/components-vue 3.16.0-rc.1 → 3.16.0-rc.2

package/esm/lib/components/FieldsetWrapperWrapper.vue.d.ts

@@ -0,0 +1,72 @@
+import type { FieldsetWrapperLabelSize, FieldsetWrapperState, Theme } from '../types';
+type PFieldsetWrapperProps = {
+    /**
+     * The label text.
+     */
+    label?: string;
+    /**
+     * The size of the label text.
+     */
+    labelSize?: FieldsetWrapperLabelSize;
+    /**
+     * The message styled depending on validation state.
+     */
+    message?: string;
+    /**
+     * Marks the Fieldset as required.
+     */
+    required?: boolean;
+    /**
+     * The validation state.
+     */
+    state?: FieldsetWrapperState;
+    /**
+     * Adapts color depending on theme.
+     */
+    theme?: Theme;
+};
+/** @deprecated since v3.0.0, will be removed with next major release. Please use "p-fieldset" instead. */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PFieldsetWrapperProps>, {
+    label: string;
+    labelSize: string;
+    message: string;
+    required: boolean;
+    state: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PFieldsetWrapperProps>, {
+    label: string;
+    labelSize: string;
+    message: string;
+    required: boolean;
+    state: string;
+}>>>, {
+    label: string;
+    state: "none" | "success" | "error";
+    required: boolean;
+    message: string;
+    labelSize: "small" | "medium";
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/FlexItemWrapper.vue.d.ts

@@ -0,0 +1,75 @@
+import type { BreakpointCustomizable, FlexItemAlignSelf, FlexItemFlex, FlexItemGrow, FlexItemOffset, FlexItemShrink, FlexItemWidth } from '../types';
+type PFlexItemProps = {
+    /**
+     * Defines how this flex item is aligned along the cross axis. This overwrites the cross axis alignment set by the container. Corresponds to the "alignSelf" css property.
+     */
+    alignSelf?: BreakpointCustomizable<FlexItemAlignSelf>;
+    /**
+     * The shorthand property for the combined definition of "shrink", "grow" and "basis"
+     */
+    flex?: BreakpointCustomizable<FlexItemFlex>;
+    /**
+     * The ability to allow/disallow the flex child to grow.
+     */
+    grow?: BreakpointCustomizable<FlexItemGrow>;
+    /**
+     * The offset of the column. You can also supply values for specific breakpoints, like {base: "none", l: "one-quarter"}. You always need to provide a base value when doing this.
+     */
+    offset?: BreakpointCustomizable<FlexItemOffset>;
+    /**
+     * The ability to allow/disallow the flex child to shrink.
+     */
+    shrink?: BreakpointCustomizable<FlexItemShrink>;
+    /**
+     * The width of the flex item. You can also supply values for specific breakpoints, like {base: "full", l: "one-quarter"}. You always need to provide a base value when doing this.
+     */
+    width?: BreakpointCustomizable<FlexItemWidth>;
+};
+/** @deprecated since v3.0.0, will be removed with next major release. Use native CSS Flex instead. */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlexItemProps>, {
+    alignSelf: string;
+    flex: string;
+    grow: number;
+    offset: string;
+    shrink: number;
+    width: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlexItemProps>, {
+    alignSelf: string;
+    flex: string;
+    grow: number;
+    offset: string;
+    shrink: number;
+    width: string;
+}>>>, {
+    width: BreakpointCustomizable<"auto" | "full" | "one-quarter" | "one-third" | "half" | "two-thirds" | "three-quarters">;
+    alignSelf: BreakpointCustomizable<"auto" | "center" | "flex-start" | "flex-end" | "stretch" | "baseline">;
+    flex: BreakpointCustomizable<"none" | "auto" | "initial" | "equal">;
+    grow: BreakpointCustomizable<0 | 1>;
+    offset: BreakpointCustomizable<"none" | "one-quarter" | "one-third" | "half" | "two-thirds" | "three-quarters">;
+    shrink: BreakpointCustomizable<0 | 1>;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/FlexWrapper.vue.d.ts

@@ -0,0 +1,75 @@
+import type { BreakpointCustomizable, FlexAlignContent, FlexAlignItems, FlexDirection, FlexInline, FlexJustifyContent, FlexWrap } from '../types';
+type PFlexProps = {
+    /**
+     * This aligns a flex container's individual lines when there is extra space in the cross-axis, similar to how "justifyContent" aligns individual items along the main axis.
+     */
+    alignContent?: BreakpointCustomizable<FlexAlignContent>;
+    /**
+     * Defines how the flex items are aligned along the cross axis.
+     */
+    alignItems?: BreakpointCustomizable<FlexAlignItems>;
+    /**
+     * Defines the direction of the main and cross axis. The default "row" defines the main axis as horizontal left to right.
+     */
+    direction?: BreakpointCustomizable<FlexDirection>;
+    /**
+     * Defines the flex containers content flow if 2 or more containers are siblings of each other.
+     */
+    inline?: BreakpointCustomizable<FlexInline>;
+    /**
+     * Defines how the flex items are aligned along the main axis.
+     */
+    justifyContent?: BreakpointCustomizable<FlexJustifyContent>;
+    /**
+     * Handles wrapping behaviour of elements.
+     */
+    wrap?: BreakpointCustomizable<FlexWrap>;
+};
+/** @deprecated since v3.0.0, will be removed with next major release. Use native CSS Flex instead. */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlexProps>, {
+    alignContent: string;
+    alignItems: string;
+    direction: string;
+    inline: boolean;
+    justifyContent: string;
+    wrap: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlexProps>, {
+    alignContent: string;
+    alignItems: string;
+    direction: string;
+    inline: boolean;
+    justifyContent: string;
+    wrap: string;
+}>>>, {
+    inline: BreakpointCustomizable<boolean>;
+    wrap: BreakpointCustomizable<"nowrap" | "wrap" | "wrap-reverse">;
+    direction: BreakpointCustomizable<"row" | "column" | "row-reverse" | "column-reverse">;
+    alignContent: BreakpointCustomizable<"center" | "flex-start" | "flex-end" | "space-between" | "space-around" | "space-evenly" | "stretch">;
+    alignItems: BreakpointCustomizable<"center" | "flex-start" | "flex-end" | "stretch" | "baseline">;
+    justifyContent: BreakpointCustomizable<"center" | "flex-start" | "flex-end" | "space-between" | "space-around" | "space-evenly">;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/FlyoutMultilevelItemWrapper.vue.d.ts

@@ -0,0 +1,28 @@
+type PFlyoutMultilevelItemProps = {
+    /**
+     * Unique identifier which controls if this item should be shown when the active-identifier on the flyout-multilevel is set to this value.
+     */
+    identifier: string;
+    /**
+     * Label of the item.
+     */
+    label?: string;
+};
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_TypePropsToOption<PFlyoutMultilevelItemProps>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<PFlyoutMultilevelItemProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/FlyoutMultilevelItemWrapper.vue.mjs

@@ -0,0 +1,24 @@
+import { defineComponent as s, ref as l, onMounted as f, onUpdated as m, openBlock as c, createBlock as i, resolveDynamicComponent as a, unref as u, withCtx as d, renderSlot as _ } from "vue";
+import { usePrefix as y, syncProperties as C } from "../../utils.mjs";
+const P = /* @__PURE__ */ s({
+  __name: "FlyoutMultilevelItemWrapper",
+  props: {
+    identifier: {},
+    label: {}
+  },
+  setup(t) {
+    const n = y("p-flyout-multilevel-item"), r = t, e = l(), o = () => C(e, r);
+    return f(o), m(o), (p, k) => (c(), i(a(u(n)), {
+      ref_key: "pdsComponentRef",
+      ref: e
+    }, {
+      default: d(() => [
+        _(p.$slots, "default")
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+export {
+  P as default
+};

package/esm/lib/components/FlyoutMultilevelItemWrapper.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./FlyoutMultilevelItemWrapper.vue.mjs";
+export {
+  f as default
+};

package/esm/lib/components/FlyoutMultilevelWrapper.vue.d.ts

@@ -0,0 +1,53 @@
+import type { SelectedAriaAttributes, FlyoutMultilevelAriaAttribute, Theme } from '../types';
+type PFlyoutMultilevelProps = {
+    /**
+     * Defines which flyout-multilevel-item to be visualized as opened.
+     */
+    activeIdentifier?: string | undefined;
+    /**
+     * Add ARIA attributes.
+     */
+    aria?: SelectedAriaAttributes<FlyoutMultilevelAriaAttribute>;
+    /**
+     * If true, the flyout-multilevel is visualized as opened.
+     */
+    open?: boolean;
+    /**
+     * Adapts the flyout-multilevel color depending on the theme.
+     */
+    theme?: Theme;
+};
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlyoutMultilevelProps>, {
+    open: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: unknown[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlyoutMultilevelProps>, {
+    open: boolean;
+}>>>, {
+    open: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/FlyoutMultilevelWrapper.vue.mjs

@@ -0,0 +1,31 @@
+import { defineComponent as c, ref as f, inject as d, onMounted as u, onUpdated as h, watch as y, openBlock as _, createBlock as v, resolveDynamicComponent as C, unref as R, withCtx as k, renderSlot as w } from "vue";
+import { usePrefix as x, themeInjectionKey as B, addEventListenerToElementRef as m, syncProperties as p } from "../../utils.mjs";
+const I = /* @__PURE__ */ c({
+  __name: "FlyoutMultilevelWrapper",
+  props: {
+    activeIdentifier: {},
+    aria: {},
+    open: { type: Boolean, default: !1 },
+    theme: {}
+  },
+  emits: ["dismiss", "update"],
+  setup(i, { emit: a }) {
+    const l = x("p-flyout-multilevel"), t = i, e = f(), n = a, s = d(B), r = () => p(e, { ...t, theme: t.theme || s.value });
+    return u(() => {
+      r(), m(e, "dismiss", n), m(e, "update", n);
+    }), h(r), y(s, (o) => {
+      p(e, { theme: t.theme || o });
+    }), (o, P) => (_(), v(C(R(l)), {
+      ref_key: "pdsComponentRef",
+      ref: e
+    }, {
+      default: k(() => [
+        w(o.$slots, "default")
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+export {
+  I as default
+};

package/esm/lib/components/FlyoutMultilevelWrapper.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./FlyoutMultilevelWrapper.vue.mjs";
+export {
+  f as default
+};

package/esm/lib/components/FlyoutWrapper.vue.d.ts

@@ -0,0 +1,63 @@
+import type { SelectedAriaAttributes, FlyoutAriaAttribute, FlyoutPosition, Theme } from '../types';
+type PFlyoutProps = {
+    /**
+     * Add ARIA attributes.
+     */
+    aria?: SelectedAriaAttributes<FlyoutAriaAttribute>;
+    /**
+     * If true, the flyout will not be closable via backdrop click.
+     */
+    disableBackdropClick?: boolean;
+    /**
+     * If true, the flyout is open.
+     */
+    open: boolean;
+    /**
+     * The position of the flyout
+     */
+    position?: FlyoutPosition;
+    /**
+     * Adapts the flyout color depending on the theme.
+     */
+    theme?: Theme;
+};
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlyoutProps>, {
+    disableBackdropClick: boolean;
+    open: boolean;
+    position: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: unknown[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PFlyoutProps>, {
+    disableBackdropClick: boolean;
+    open: boolean;
+    position: string;
+}>>>, {
+    open: boolean;
+    disableBackdropClick: boolean;
+    position: "start" | "end" | "left" | "right";
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/GridItemWrapper.vue.d.ts

@@ -0,0 +1,47 @@
+import type { BreakpointCustomizable, GridItemOffset, GridItemSize } from '../types';
+type PGridItemProps = {
+    /**
+     * The offset of the column. Can be between 0 and 11. Also defines the offset of the column for specific breakpoints, like {base: 6, l: 3}. You always need to provide a base value when doing this.
+     */
+    offset?: BreakpointCustomizable<GridItemOffset>;
+    /**
+     * The size of the column. Can be between 1 and 12. Also defines the size of the column for specific breakpoints, like {base: 6, l: 3}. You always need to provide a base value when doing this.
+     */
+    size?: BreakpointCustomizable<GridItemSize>;
+};
+/** @deprecated since v3.0.0, will be removed with next major release. Use native CSS Grid instead. */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PGridItemProps>, {
+    offset: number;
+    size: number;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PGridItemProps>, {
+    offset: number;
+    size: number;
+}>>>, {
+    size: BreakpointCustomizable<3 | 4 | 2 | 7 | 5 | 1 | 6 | 12 | 8 | 9 | 10 | 11>;
+    offset: BreakpointCustomizable<0 | 3 | 4 | 2 | 7 | 5 | 1 | 6 | 8 | 9 | 10 | 11>;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/GridWrapper.vue.d.ts

@@ -0,0 +1,63 @@
+import type { BreakpointCustomizable, GridDirection, GridGutter, GridWrap } from '../types';
+type PGridProps = {
+    /**
+     * Defines the direction of the main and cross axis. The default "row" defines the main axis as horizontal left to right. Also defines the direction for specific breakpoints, like {base: "column", l: "row"}. You always need to provide a base value when doing this.
+     */
+    direction?: BreakpointCustomizable<GridDirection>;
+    /**
+     * Has no effect anymore
+     * @deprecated since v3.0.0, will be removed with next major release
+     */
+    gutter?: BreakpointCustomizable<GridGutter>;
+    /**
+     * Handles wrapping behaviour of elements.
+     */
+    wrap?: BreakpointCustomizable<GridWrap>;
+};
+/** @deprecated since v3.0.0, will be removed with next major release. Use native CSS Grid instead. */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PGridProps>, {
+    direction: string;
+    gutter: () => {
+        base: number;
+        s: number;
+        m: number;
+    };
+    wrap: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PGridProps>, {
+    direction: string;
+    gutter: () => {
+        base: number;
+        s: number;
+        m: number;
+    };
+    wrap: string;
+}>>>, {
+    wrap: BreakpointCustomizable<"nowrap" | "wrap">;
+    direction: BreakpointCustomizable<"row" | "column" | "row-reverse" | "column-reverse">;
+    gutter: BreakpointCustomizable<16 | 24 | 36>;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/esm/lib/components/HeadingWrapper.vue.d.ts

@@ -0,0 +1,68 @@
+import type { HeadingAlign, HeadingColor, BreakpointCustomizable, HeadingSize, HeadingTag, Theme } from '../types';
+type PHeadingProps = {
+    /**
+     * Text alignment of the component.
+     */
+    align?: HeadingAlign;
+    /**
+     * Basic text color variations depending on theme property.
+     */
+    color?: HeadingColor;
+    /**
+     * Adds an ellipsis to a single line of text if it overflows.
+     */
+    ellipsis?: boolean;
+    /**
+     * Size of the component. Also defines the size for specific breakpoints, like {base: "small", l: "medium"}. You always need to provide a base value when doing this.
+     */
+    size?: BreakpointCustomizable<HeadingSize>;
+    /**
+     * Sets a heading tag, so it fits correctly within the outline of the page.
+     */
+    tag?: HeadingTag;
+    /**
+     * Adapts the text color depending on the theme. Has no effect when "inherit" is set as color prop.
+     */
+    theme?: Theme;
+};
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<PHeadingProps>, {
+    align: string;
+    color: string;
+    ellipsis: boolean;
+    size: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<PHeadingProps>, {
+    align: string;
+    color: string;
+    ellipsis: boolean;
+    size: string;
+}>>>, {
+    size: BreakpointCustomizable<"inherit" | "small" | "medium" | "large" | "x-large" | "xx-large">;
+    align: "center" | "start" | "end" | "left" | "right";
+    color: "inherit" | "primary";
+    ellipsis: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};