prismify-ui 0.1.0-alpha.1

package/dist/components/editor/PfEditorMentionMenu/index.vue.d.ts

@@ -0,0 +1,53 @@
+import { Editor } from '@tiptap/vue-3';
+import { PfEditorMentionMenuItem } from '../utils/types';
+type __VLS_Props = {
+    editor?: Editor;
+    items?: PfEditorMentionMenuItem[] | PfEditorMentionMenuItem[][];
+    char?: string;
+    pluginKey?: string;
+    filterFields?: string[];
+    limit?: number;
+    ignoreFilter?: boolean;
+    searchTerm?: string;
+    ui?: Partial<{
+        content: string;
+        viewport: string;
+        group: string;
+        label: string;
+        separator: string;
+        item: string;
+        itemLeadingIcon: string;
+        itemLeadingAvatar: string;
+        itemWrapper: string;
+        itemLabel: string;
+        itemDescription: string;
+    }>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:searchTerm": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+}>, {
+    ui: Partial<{
+        content: string;
+        viewport: string;
+        group: string;
+        label: string;
+        separator: string;
+        item: string;
+        itemLeadingIcon: string;
+        itemLeadingAvatar: string;
+        itemWrapper: string;
+        itemLabel: string;
+        itemDescription: string;
+    }>;
+    items: PfEditorMentionMenuItem[] | PfEditorMentionMenuItem[][];
+    filterFields: string[];
+    ignoreFilter: boolean;
+    searchTerm: string;
+    editor: Editor;
+    pluginKey: string;
+    char: string;
+    limit: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/editor/PfEditorSuggestionMenu/index.vue.d.ts

@@ -0,0 +1,49 @@
+import { Editor } from '@tiptap/vue-3';
+import { PfEditorCustomHandlers, PfEditorSuggestionMenuItem } from '../utils/types';
+type __VLS_Props = {
+    editor?: Editor;
+    handlers?: PfEditorCustomHandlers;
+    items?: PfEditorSuggestionMenuItem[] | PfEditorSuggestionMenuItem[][];
+    char?: string;
+    pluginKey?: string;
+    filterFields?: string[];
+    limit?: number;
+    appendTo?: HTMLElement | (() => HTMLElement);
+    options?: Record<string, unknown>;
+    ui?: Partial<{
+        content: string;
+        viewport: string;
+        group: string;
+        label: string;
+        separator: string;
+        item: string;
+        itemLeadingIcon: string;
+        itemWrapper: string;
+        itemLabel: string;
+        itemDescription: string;
+    }>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    ui: Partial<{
+        content: string;
+        viewport: string;
+        group: string;
+        label: string;
+        separator: string;
+        item: string;
+        itemLeadingIcon: string;
+        itemWrapper: string;
+        itemLabel: string;
+        itemDescription: string;
+    }>;
+    items: PfEditorSuggestionMenuItem[] | PfEditorSuggestionMenuItem[][];
+    options: Record<string, unknown>;
+    filterFields: string[];
+    handlers: PfEditorCustomHandlers;
+    editor: Editor;
+    pluginKey: string;
+    char: string;
+    appendTo: HTMLElement | (() => HTMLElement);
+    limit: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/editor/PfEditorToolbar/index.vue.d.ts

@@ -0,0 +1,67 @@
+import { Editor } from '@tiptap/vue-3';
+import { PfDropdownMenuContent } from '../../overlay/PfDropdownMenu/types';
+import { PfEditorCustomHandlers, PfEditorToolbarItem } from '../utils/types';
+type __VLS_Props = {
+    editor?: Editor;
+    handlers?: PfEditorCustomHandlers;
+    items?: PfEditorToolbarItem[] | PfEditorToolbarItem[][];
+    layout?: 'fixed' | 'bubble' | 'floating';
+    pluginKey?: unknown;
+    updateDelay?: number;
+    resizeDelay?: number;
+    shouldShow?: (...args: any[]) => boolean;
+    appendTo?: unknown;
+    options?: unknown;
+    content?: PfDropdownMenuContent;
+    ui?: Partial<{
+        root: string;
+        base: string;
+        group: string;
+        separator: string;
+    }>;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: {
+        item: PfEditorToolbarItem;
+        editor: Editor;
+        handlers: PfEditorCustomHandlers;
+    }) => any>> & Partial<Record<string, (_: {
+        item: PfEditorToolbarItem;
+        editor: Editor;
+        handlers: PfEditorCustomHandlers;
+    }) => any>> & Partial<Record<string, (_: {
+        item: PfEditorToolbarItem;
+        editor: Editor;
+        handlers: PfEditorCustomHandlers;
+    }) => any>>;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    ui: Partial<{
+        root: string;
+        base: string;
+        group: string;
+        separator: string;
+    }>;
+    content: PfDropdownMenuContent;
+    items: PfEditorToolbarItem[] | PfEditorToolbarItem[][];
+    options: undefined;
+    layout: "fixed" | "bubble" | "floating";
+    handlers: PfEditorCustomHandlers;
+    editor: Editor;
+    pluginKey: undefined;
+    shouldShow: (...args: any[]) => boolean;
+    updateDelay: number;
+    resizeDelay: number;
+    appendTo: undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/editor/utils/handlers.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from '@tiptap/vue-3';
+import { PfEditorCommandItem, PfEditorCustomHandlers } from './types';
+export declare function createEditorHandlers(customHandlers?: PfEditorCustomHandlers): PfEditorCustomHandlers;
+export declare function runEditorHandler(editor: Editor, handlers: PfEditorCustomHandlers, item: PfEditorCommandItem): boolean;
+export declare function resolveItemDisabled(editor: Editor, handlers: PfEditorCustomHandlers, item: PfEditorCommandItem): boolean;
+export declare function resolveItemActive(editor: Editor, handlers: PfEditorCustomHandlers, item: PfEditorCommandItem): boolean;
+export declare function shouldApplyInlineHandler(editor: Editor): boolean;

package/dist/components/editor/utils/injection.d.ts

@@ -0,0 +1,8 @@
+import { InjectionKey, Ref } from 'vue';
+import { Editor } from '@tiptap/vue-3';
+import { PfEditorCustomHandlers } from './types';
+export interface PfEditorContextValue {
+    editor: Ref<Editor | undefined>;
+    handlers: Ref<PfEditorCustomHandlers>;
+}
+export declare const PF_EDITOR_INJECTION_KEY: InjectionKey<PfEditorContextValue>;

package/dist/components/editor/utils/mapEditorItems.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from '@tiptap/vue-3';
+import { PfDropdownMenuItem } from '../../overlay/PfDropdownMenu/types';
+import { PfEditorCustomHandlers, PfEditorSuggestionMenuItem, PfEditorToolbarItem } from './types';
+type EditorMappableItem = PfEditorToolbarItem | PfEditorSuggestionMenuItem;
+export declare function mapEditorItem(editor: Editor, item: EditorMappableItem, handlers: PfEditorCustomHandlers): PfDropdownMenuItem;
+export declare function mapEditorItems(editor: Editor, items: EditorMappableItem[] | EditorMappableItem[][], handlers: PfEditorCustomHandlers): PfDropdownMenuItem[][];
+export {};

package/dist/components/editor/utils/types.d.ts

@@ -0,0 +1,98 @@
+import { ChainedCommands, Editor, Extensions, JSONContent } from '@tiptap/vue-3';
+import { MentionOptions } from '@tiptap/extension-mention';
+import { PlaceholderOptions } from '@tiptap/extension-placeholder';
+import { ImageOptions } from '@tiptap/extension-image';
+import { NodeRangeOptions } from '@tiptap/extension-node-range';
+import { StarterKitOptions } from '@tiptap/starter-kit';
+export type PfEditorContentType = 'json' | 'html' | 'markdown';
+export type PfEditorAlign = 'left' | 'center' | 'right' | 'justify';
+export interface PfEditorHandler<TItem = unknown> {
+    canExecute: (editor: Editor, item?: TItem) => boolean;
+    execute: (editor: Editor, item?: TItem) => ChainedCommands;
+    isActive: (editor: Editor, item?: TItem) => boolean;
+    isDisabled?: (editor: Editor, item?: TItem) => boolean;
+}
+export type PfEditorCustomHandlers = Record<string, PfEditorHandler<any>>;
+export interface PfEditorCommandItem {
+    kind?: string;
+    mark?: string;
+    align?: PfEditorAlign;
+    level?: number;
+    language?: string;
+    pos?: number;
+}
+export interface PfEditorToolbarItem extends PfEditorCommandItem {
+    type?: 'label' | 'separator';
+    label?: string;
+    description?: string;
+    icon?: string;
+    color?: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+    activeColor?: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+    variant?: 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
+    activeVariant?: 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    slot?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    active?: boolean;
+    to?: string;
+    download?: boolean;
+    class?: string;
+    items?: PfEditorToolbarItem[] | PfEditorToolbarItem[][];
+    onClick?: (event: MouseEvent) => void;
+}
+export type PfEditorSuggestionMenuItem = Omit<PfEditorToolbarItem, 'items'> & {
+    items?: never;
+};
+export interface PfEditorMentionMenuItem {
+    id?: string | number;
+    label: string;
+    icon?: string;
+    description?: string;
+    disabled?: boolean;
+    avatar?: {
+        src?: string;
+        alt?: string;
+        icon?: string;
+        text?: string;
+        size?: '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+        loading?: 'eager' | 'lazy';
+    };
+}
+export interface PfEditorEmojiMenuItem {
+    name: string;
+    emoji: string;
+    shortcodes?: string[];
+    tags?: string[];
+    group?: string;
+    fallbackImage?: string;
+}
+export interface PfEditorUi {
+    root?: string;
+    content?: string;
+    base?: string;
+}
+export interface PfEditorProps {
+    modelValue?: null | string | JSONContent | JSONContent[];
+    contentType?: PfEditorContentType;
+    starterKit?: Partial<StarterKitOptions>;
+    placeholder?: string | (Partial<PlaceholderOptions> & {
+        mode?: 'firstLine' | 'everyLine';
+    });
+    markdown?: Partial<{
+        markedOptions: Record<string, unknown>;
+    }> | false;
+    image?: boolean | Partial<ImageOptions>;
+    mention?: boolean | Partial<Omit<MentionOptions<any, any>, 'suggestion' | 'suggestions'>>;
+    handlers?: PfEditorCustomHandlers;
+    /**
+     * Required for correct block drag-and-drop (`PfEditorDragHandle` / `@tiptap/extension-drag-handle`).
+     * Enabled by default; pass `false` to disable.
+     */
+    nodeRange?: boolean | Partial<NodeRangeOptions>;
+    extensions?: Extensions;
+    editable?: boolean;
+    autofocus?: boolean | 'start' | 'end' | 'all';
+    textDirection?: 'ltr' | 'rtl' | 'auto';
+    ui?: PfEditorUi;
+}

package/dist/components/editor/utils/useEditorMenu.d.ts

@@ -0,0 +1,31 @@
+import { Editor } from '@tiptap/vue-3';
+type MenuItem = Record<string, any>;
+interface UseEditorMenuOptions<TItem extends MenuItem> {
+    editor: () => Editor | null | undefined;
+    char: string;
+    items: TItem[] | TItem[][];
+    limit?: number;
+    filterFields?: string[];
+    ignoreFilter?: boolean;
+}
+export declare function useEditorMenu<TItem extends MenuItem>(options: UseEditorMenuOptions<TItem>): {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    searchTerm: import('vue').Ref<string, string>;
+    selectedIndex: import('vue').Ref<number, number>;
+    flatItems: import('vue').ComputedRef<any[]>;
+    activeItem: import('vue').ComputedRef<any>;
+    range: import('vue').Ref<{
+        from: number;
+        to: number;
+    } | null, {
+        from: number;
+        to: number;
+    } | {
+        from: number;
+        to: number;
+    } | null>;
+    closeMenu: () => void;
+    replaceTriggerWith: (editor: Editor, content: string) => boolean;
+    getFilteredGroups: () => TItem[][];
+};
+export {};

package/dist/components/element/PfAlert/index.vue.d.ts

@@ -0,0 +1,98 @@
+import { Component } from 'vue';
+import { PfIconName } from '../PfIcon/paths';
+import { PfBadgeAvatarProps } from '../PfBadge/index.vue';
+export type PfAlertAvatarProps = PfBadgeAvatarProps;
+export type PfAlertColor = 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'neutral';
+export type PfAlertVariant = 'solid' | 'outline' | 'soft' | 'subtle';
+export type PfAlertButtonVariant = 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
+export type PfAlertActionProps = Partial<{
+    label: string;
+    color: PfAlertColor;
+    variant: PfAlertButtonVariant;
+    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    square: boolean;
+    block: boolean;
+    icon: PfIconName;
+    leading: boolean;
+    leadingIcon: PfIconName;
+    trailing: boolean;
+    trailingIcon: PfIconName;
+    iconOnly: boolean;
+    ariaLabel: string;
+    disabled: boolean;
+    loading: boolean;
+    loadingIcon: PfIconName;
+    loadingAuto: boolean;
+    type: 'button' | 'submit' | 'reset';
+    href: string;
+    to: string;
+    target: string;
+    rel: string;
+    download: boolean | string;
+    active: boolean;
+    activeColor: PfAlertColor;
+    activeVariant: PfAlertButtonVariant;
+}>;
+export type PfAlertCloseButtonProps = Omit<PfAlertActionProps, 'href' | 'to' | 'target' | 'rel' | 'download'>;
+export type PfAlertUi = Partial<{
+    root: string;
+    leading: string;
+    wrapper: string;
+    title: string;
+    description: string;
+    icon: string;
+    avatar: string;
+    actions: string;
+    end: string;
+    close: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    title?: string;
+    description?: string;
+    icon?: PfIconName;
+    avatar?: PfAlertAvatarProps;
+    color?: PfAlertColor;
+    variant?: PfAlertVariant;
+    orientation?: 'vertical' | 'horizontal';
+    actions?: PfAlertActionProps[];
+    close?: boolean | PfAlertCloseButtonProps;
+    closeIcon?: PfIconName;
+    ui?: PfAlertUi;
+};
+declare function onCloseClick(): void;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        title?(_: {}): any;
+        description?(_: {}): any;
+        actions?(_: {}): any;
+        actions?(_: {}): any;
+        close?(_: {
+            close: typeof onCloseClick;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    color: PfAlertColor;
+    variant: PfAlertVariant;
+    orientation: "vertical" | "horizontal";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/element/PfAvatar/index.vue.d.ts

@@ -0,0 +1,43 @@
+import { Component } from 'vue';
+import { PfIconName } from '../PfIcon/paths';
+export type PfAvatarChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfAvatarChipProps = {
+    color?: PfAvatarChipColor;
+};
+type __VLS_Props = {
+    /**
+     * Override image tag/component: default `img`;
+     * with Nuxt `@nuxt/image` usually `{ img: 'NuxtImg' }` (string from global registration).
+     * Keep `<img>` explicitly: `{ img: 'img' }`. For a component object in `setup`, use `markRaw(Comp)`.
+     */
+    as?: {
+        img?: string | Component;
+    };
+    src?: string;
+    alt?: string;
+    icon?: PfIconName;
+    text?: string;
+    size?: '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+    /** Ring around the avatar; object sets ring color. */
+    chip?: boolean | PfAvatarChipProps;
+    loading?: 'lazy' | 'eager';
+    /** See [fetchpriority](https://developer.mozilla.org/docs/Web/HTML/Element/img#fetchpriority) */
+    fetchPriority?: 'high' | 'low' | 'auto';
+    /** See [referrerpolicy](https://developer.mozilla.org/docs/Web/HTML/Element/img#referrerpolicy) */
+    referrerpolicy?: string;
+    crossorigin?: '' | 'anonymous' | 'use-credentials';
+    decoding?: 'async' | 'auto' | 'sync';
+    height?: number | string;
+    sizes?: string;
+    srcset?: string;
+    usemap?: string;
+    width?: number | string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+}>, {
+    size: "3xs" | "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/element/PfAvatarGroup/index.vue.d.ts

@@ -0,0 +1,52 @@
+import { VNode, Component, PropType } from 'vue';
+import { PfAvatarGroupSize } from './injection';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * Root tag or component (like `component :is`).
+     */
+    as: {
+        type: PropType<string | Component>;
+        default: string;
+    };
+    /** Size for all avatars in the group (via provide to `PfAvatar`). */
+    size: {
+        type: PropType<PfAvatarGroupSize>;
+        default: string;
+    };
+    /**
+     * Max visible face avatars from the slot; rest collapse into `+N`.
+     * Omitted or ≤ 0 — no limit.
+     */
+    max: {
+        type: PropType<number | string | undefined>;
+        default: undefined;
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * Root tag or component (like `component :is`).
+     */
+    as: {
+        type: PropType<string | Component>;
+        default: string;
+    };
+    /** Size for all avatars in the group (via provide to `PfAvatar`). */
+    size: {
+        type: PropType<PfAvatarGroupSize>;
+        default: string;
+    };
+    /**
+     * Max visible face avatars from the slot; rest collapse into `+N`.
+     * Omitted or ≤ 0 — no limit.
+     */
+    max: {
+        type: PropType<number | string | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: PfAvatarGroupSize;
+    as: string | Component;
+    max: string | number | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/element/PfAvatarGroup/injection.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef, InjectionKey } from 'vue';
+export type PfAvatarGroupSize = '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+export type PfAvatarGroupInjected = {
+    size: PfAvatarGroupSize;
+};
+export declare const PF_AVATAR_GROUP_INJECTION_KEY: InjectionKey<ComputedRef<PfAvatarGroupInjected>>;

package/dist/components/element/PfBadge/index.vue.d.ts

@@ -0,0 +1,64 @@
+import { Component } from 'vue';
+import { PfAvatarChipProps } from '../PfAvatar/index.vue';
+import { PfIconName } from '../PfIcon/paths';
+export type PfBadgeAvatarProps = {
+    as?: {
+        img?: string | Component;
+    };
+    src?: string;
+    alt?: string;
+    icon?: PfIconName;
+    text?: string;
+    size?: '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+    chip?: boolean | PfAvatarChipProps;
+    loading?: 'lazy' | 'eager';
+    fetchPriority?: 'high' | 'low' | 'auto';
+    referrerpolicy?: string;
+    crossorigin?: '' | 'anonymous' | 'use-credentials';
+    decoding?: 'async' | 'auto' | 'sync';
+    height?: number | string;
+    sizes?: string;
+    srcset?: string;
+    usemap?: string;
+    width?: number | string;
+};
+type __VLS_Props = {
+    as?: string | Component;
+    label?: string | number;
+    color?: 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'neutral';
+    variant?: 'solid' | 'outline' | 'soft' | 'subtle';
+    /** In `PfFieldGroup`, inherits group `size` when no own `size` */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    square?: boolean;
+    icon?: PfIconName;
+    avatar?: PfBadgeAvatarProps;
+    leading?: boolean;
+    leadingIcon?: PfIconName;
+    trailing?: boolean;
+    trailingIcon?: PfIconName;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        default?(_: {}): any;
+        trailing?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    square: boolean;
+    color: "error" | "primary" | "secondary" | "success" | "info" | "warning" | "neutral";
+    variant: "solid" | "outline" | "soft" | "subtle";
+    leading: boolean;
+    trailing: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/element/PfBanner/index.vue.d.ts

@@ -0,0 +1,67 @@
+import { Component } from 'vue';
+import { PfIconName } from '../PfIcon/paths';
+import { PfAlertActionProps, PfAlertCloseButtonProps } from '../PfAlert/index.vue';
+export type PfBannerColor = 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'neutral';
+/** Button props for the `actions` prop (like `PfAlert`). */
+export type PfBannerActionProps = PfAlertActionProps;
+export type PfBannerCloseButtonProps = PfAlertCloseButtonProps;
+export type PfBannerUi = Partial<{
+    root: string;
+    container: string;
+    left: string;
+    center: string;
+    right: string;
+    link: string;
+    icon: string;
+    title: string;
+    actions: string;
+    close: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    /** Unique id: on close, written to `localStorage`; banner stays hidden after reload. */
+    id?: string;
+    title?: string;
+    icon?: PfIconName;
+    color?: PfBannerColor;
+    actions?: PfBannerActionProps[];
+    /** Link: `href` wins over `to` */
+    href?: string;
+    to?: string;
+    target?: '_blank' | '_parent' | '_self' | '_top' | string;
+    rel?: string;
+    close?: boolean | PfBannerCloseButtonProps;
+    closeIcon?: PfIconName;
+    ui?: PfBannerUi;
+};
+declare function dismissBanner(ev?: Event): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        leading?(_: {}): any;
+        title?(_: {}): any;
+        title?(_: {}): any;
+        actions?(_: {}): any;
+        close?(_: {
+            close: typeof dismissBanner;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    color: PfBannerColor;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};