primevue 3.9.1 → 3.10.0

package/tieredmenu/TieredMenu.d.ts

@@ -1,24 +1,98 @@
-interface TieredMenuProps {
-    popup?: boolean;
-    model?: any[];
-    appendTo?: string;
-    autoZIndex?: boolean;
-    baseZIndex?: number;
-    exact?: boolean;
+import { VNode } from 'vue';
+import { ClassComponent, GlobalComponentConstructor } from '../ts-helpers';
+import { MenuItem } from '../menuitem';
+
+type TieredMenuAppandToType = 'body' | 'self' | string | undefined;
+
+export interface TieredMenuProps {
+    /**
+     * An array of menuitems.
+     */
+    model?: MenuItem[] | undefined;
+    /**
+     * Defines if menu would displayed as a popup.
+     */
+    popup?: boolean | undefined;
+    /**
+     * A valid query selector or an HTMLElement to specify where the overlay gets attached.
+     * @see TieredMenuAppandToType
+     * Default value is 'body'.
+     */
+    appendTo?: TieredMenuAppandToType;
+    /**
+     * Whether to automatically manage layering.
+     * Default value is true.
+     */
+    autoZIndex?: boolean | undefined;
+    /**
+     * Base zIndex value to use in layering.
+     * Default value is 0.
+     */
+    baseZIndex?: number | undefined;
+    /**
+     * Whether to apply 'router-link-active-exact' class if route exactly matches the item path.
+     * Default value is true.
+     */
+    exact?: boolean | undefined;
+}
+
+export interface TieredMenuSlots {
+    /**
+     * Custom content for each item.
+     * @param {Object} scope - item slot's params.
+     */
+    item: (scope: {
+        /**
+         * Menuitem instance
+         */
+        item: MenuItem;
+    }) => VNode[];
 }
 
-interface TieredMenuItemSlotInterface {
-    item: any;
+export declare type TieredMenuEmits = {
 }
 
-declare class TieredMenu {
-    $props: TieredMenuProps;
-    toggle(event: Event): void;
-    show(event: Event, target?: any): void;
+declare class TieredMenu extends ClassComponent<TieredMenuProps, TieredMenuSlots, TieredMenuEmits> {
+    /**
+     * Toggles the visibility of the overlay.
+     * @param {Event} event - Browser event
+     *
+     * @memberof TieredMenu
+     */
+    toggle: (event: Event) => void;
+    /**
+     * Shows the overlay.
+     * @param {Event} event - Browser event
+     * @param {*} [target] - Optional target if event.target would not be used
+     *
+     * @memberof TieredMenu
+     */
+    show: (event: Event, target?: any) => void;
+    /**
+     * Hides the overlay.
+     *
+     * @memberof TieredMenu
+     */
     hide(): void;
-    $slots: {
-        item: TieredMenuItemSlotInterface;
+}
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        TieredMenu: GlobalComponentConstructor<TieredMenu>
     }
 }
 
+/**
+ *
+ * TieredMenu displays submenus in nested overlays.
+ *
+ * Helper API:
+ *
+ * - [MenuItem](https://www.primefaces.org/primevue/showcase/#/menumodel)
+ *
+ * Demos:
+ *
+ * - [TieredMenu](https://www.primefaces.org/primevue/showcase/#/tieredmenu)
+ *
+ */
 export default TieredMenu;

package/timeline/Timeline.d.ts

@@ -1,25 +1,104 @@
 import { VNode } from 'vue';
+import { ClassComponent, GlobalComponentConstructor } from '../ts-helpers';
 
-interface TimelineProps {
-    value?: any[];
-    align?: string;
-    layout?: string;
-    dataKey?: string;
+type TimelineVerticalAlignType = 'left' | 'right' | undefined;
+
+type TimelineHorizontalAlignType = 'top' | 'bottom' | undefined;
+
+type TimelineAlignType = TimelineVerticalAlignType | TimelineHorizontalAlignType | undefined;
+
+type TimelineLayoutType = 'vertical' | 'horizontal' | undefined;
+
+export interface TimelineProps {
+    /**
+     * An array of events to display.
+     */
+    value?: any[] | undefined;
+    /**
+     * Position of the timeline bar relative to the content.
+     * @see TimelineAlignType
+     * Default value is 'left'.
+     */
+    align?: TimelineAlignType;
+    /**
+     * Orientation of the timeline.
+     * @see TimelineLayoutType
+     * Default value is 'horizontal'.
+     */
+    layout?: TimelineLayoutType;
+    /**
+     * Name of the field that uniquely identifies the a record in the data.
+     */
+    dataKey?: string | undefined;
 }
 
-interface TimelineSlotInterface {
-    item: any;
-    index: number;
+export interface TimelineSlots {
+    /**
+     * Custom content template
+     * @param {Object} scope - content slot's params.
+     */
+    content: (scope: {
+        /**
+         * Item data
+         */
+        item: any;
+        /**
+         * Index of item
+         */
+        index: number;
+    }) => VNode[];
+    /**
+     * Custom opposite template.
+     * @param {Object} scope - opposite slot's params.
+     */
+    opposite: (scope: {
+        /**
+         * Item data
+         */
+        item: any;
+        /**
+         * Index of item
+         */
+        index: number;
+    }) => VNode[];
+    /**
+     * Custom marker template.
+     * @param {Object} scope - marker slot's params.
+     */
+    marker: (scope: {
+        /**
+         * Item data
+         */
+        item: any;
+        /**
+         * Index of item
+         */
+        index: number;
+    }) => VNode[];
+    /**
+     * Custom connector template.
+     */
+    connector: () => VNode[];
 }
 
-declare class Timeline {
-    $props: TimelineProps;
-    $slots: {
-        content: TimelineSlotInterface;
-        opposite: TimelineSlotInterface;
-        marker: TimelineSlotInterface;
-        connector: VNode[];
+export declare type TimelineEmits = {
+}
+
+declare class Timeline extends ClassComponent<TimelineProps, TimelineSlots, TimelineEmits> { }
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        Timeline: GlobalComponentConstructor<Timeline>
     }
 }
 
+/**
+ *
+ * Timeline visualizes a series of chained events.
+ *
+ * Demos:
+ *
+ * - [Timeline](https://www.primefaces.org/primevue/showcase/#/timeline)
+ *
+ */
 export default Timeline;

package/toast/Toast.d.ts

@@ -1,20 +1,118 @@
-interface ToastProps {
-    group?: string;
-    position?: string;
-    autoZIndex?: boolean;
-    baseZIndex?: number;
-    breakpoints?: {[key: string]: string};
+import { VNode } from 'vue';
+import { ClassComponent, GlobalComponentConstructor } from '../ts-helpers';
+
+type ToastPositionType = 'top-left' | 'top-center' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'center' | undefined;
+
+type ToastMessageSeverityType = 'success' | 'info' | 'warn' | 'error' | undefined;
+
+export interface ToastMessageOptions {
+    /**
+     * Severity level of the message.
+     * @see MessageSeverityType
+     * Default value is 'info'.
+     */
+    severity?: ToastMessageSeverityType;
+    /**
+     * Summary content of the message.
+     */
+    summary?: string | undefined;
+    /**
+     * Detail content of the message.
+     */
+    detail?: string | undefined;
+    /**
+     * Whether the message can be closed manually using the close icon.
+     * Default value is true.
+     */
+    closable?: boolean | undefined;
+    /**
+     * Delay in milliseconds to close the message automatically.
+     * Default value is 3000.
+     */
+    life?: number | undefined;
+    /**
+     * Key of the Toast to display the message.
+     */
+    group?: string | undefined;
+    /**
+     * Style class of the message.
+     */
+    styleClass?: string | undefined;
+    /**
+     * Style class of the content.
+     */
+    contentStyleClass?: string | undefined;
+}
+
+export interface ToastBreakpointsType {
+    /**
+     * Breakpoint for responsive mode.
+     *
+     * Example:
+     *
+     * <Toast :breakpoints="{'960px': { width: '75vw', ... }" ... />
+     *
+     */
+    [key: string]: any;
 }
 
-interface ToastMessageSlotInterface {
-    message: any;
+export interface ToastProps {
+    /**
+     * Unique identifier of a message group.
+     */
+    group?: string | undefined;
+    /**
+     * Position of the toast in viewport.
+     * @see ToastPositionType
+     * Default value is 'top-right'.
+     */
+    position?: ToastPositionType;
+    /**
+     * Whether to automatically manage layering.
+     * Default value is true.
+     */
+    autoZIndex?: boolean | undefined;
+    /**
+     * Base zIndex value to use in layering.
+     * Default value is 0.
+     */
+    baseZIndex?: number | undefined;
+    /**
+     * Object literal to define styles per screen size.
+     * @see ToastBreakpointsType
+     */
+    breakpoints?: ToastBreakpointsType;
 }
 
-declare class Toast {
-    $props: ToastProps;
-    $slots: {
-        message: ToastMessageSlotInterface;
+export interface ToastSlots {
+    /**
+     * Custom message template.
+     */
+    message: () => VNode[];
+}
+
+export declare type ToastEmits = {
+}
+
+declare class Toast extends ClassComponent<ToastProps, ToastSlots, ToastEmits> { }
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        Toast: GlobalComponentConstructor<Toast>
     }
 }
 
+/**
+ *
+ * Toast is used to display messages in an overlay.
+ *
+ * Helper API:
+ *
+ * - ToastService
+ *
+ * Demos:
+ *
+ * - [Toast](https://www.primefaces.org/primevue/showcase/#/toast)
+ *
+ */
 export default Toast;

package/toastservice/ToastService.d.ts

@@ -1,12 +1,24 @@
-import Vue, { Plugin } from 'vue';
+import { Plugin } from 'vue';
+import { ToastMessageOptions } from '../toast';
 
 declare const plugin: Plugin;
 export default plugin;
 
-interface ToastServiceMethods {
-    add(message: any): any;
-    removeGroup(group: any): void;
-    removeAllGroups(): void;
+export interface ToastServiceMethods {
+    /**
+     * Displays the message in a suitable Toast component.
+     * @param {ToastMessageOptions} message - Message instance.
+     */
+    add: (message: ToastMessageOptions) => void;
+    /**
+     * Clears the messages that belongs to the group.
+     * @param {string} group - Name of the message group.
+     */
+    removeGroup: (group: string) => void;
+    /**
+     * Clears all the messages.
+     */
+    removeAllGroups: () => void;
 }
 
 declare module 'vue/types/vue' {

package/togglebutton/ToggleButton.d.ts

@@ -1,16 +1,69 @@
-interface ToggleButtonProps {
-    modelValue?: boolean;
-    onIcon?: string;
-    offIcon?: string;
-    onLabel?: string;
-    offLabel?: string;
-    iconPos?: string;
+import { ClassComponent, GlobalComponentConstructor } from '../ts-helpers';
+
+type ToggleButtonType = 'left' | 'right' | undefined;
+
+export interface ToggleButtonProps {
+    /**
+     * Value of the component.
+     */
+    modelValue?: boolean | undefined;
+    /**
+     * Icon for the on state.
+     */
+    onIcon?: string | undefined;
+    /**
+     * Icon for the off state.
+     */
+    offIcon?: string | undefined;
+    /**
+     * Label for the on state.
+     * Default value is 'yes'.
+     */
+    onLabel?: string | undefined;
+    /**
+     * Label for the off state.
+     * Default value is 'no'.
+     */
+    offLabel?: string | undefined;
+    /**
+     * Position of the icon.
+     * @see ToggleButtonType
+     * Default value is 'left'.
+     */
+    iconPos?: ToggleButtonType;
+}
+
+export interface ToggleButtonSlots {
 }
 
-declare class ToggleButton {
-    $props: ToggleButtonProps;
-    $emit(eventName: 'update:modelValue', value: boolean): this;
-    $emit(eventName: 'change', event: Event): this;
+export declare type ToggleButtonEmits = {
+    /**
+     * Emitted when the value changes.
+     * @param {boolean} value - New value.
+     */
+    'update:modelValue': (value: boolean) => void;
+    /**
+     * Callback to invoke on value change.
+     * @param {Event} event - Browser event.
+     */
+    'change': (event: Event) => void;
+}
+
+declare class ToggleButton extends ClassComponent<ToggleButtonProps, ToggleButtonSlots, ToggleButtonEmits> { }
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        ToggleButton: GlobalComponentConstructor<ToggleButton>
+    }
 }
 
+/**
+ *
+ * ToggleButton is used to select a boolean value using a button.
+ *
+ * Demos:
+ *
+ * - [ToggleButton](https://www.primefaces.org/primevue/showcase/#/togglebutton)
+ *
+ */
 export default ToggleButton;

package/toolbar/Toolbar.d.ts

@@ -1,13 +1,38 @@
 import { VNode } from 'vue';
+import { ClassComponent, GlobalComponentConstructor } from '../ts-helpers';
 
-interface ToolbarProps {}
+export interface ToolbarProps {
+}
+
+export interface ToolbarSlots {
+    /**
+     * Custom start template.
+     */
+    start: () => VNode[];
+    /**
+     * Custom end template.
+     */
+    end: () => VNode[];
+}
+
+export declare type ToolbarEmits = {
+}
+
+declare class Toolbar extends ClassComponent<ToolbarProps, ToolbarSlots, ToolbarEmits> { }
 
-declare class Toolbar {
-    $props: ToolbarProps;
-    $slots: {
-        left: VNode[];
-        right: VNode[];
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        Toolbar: GlobalComponentConstructor<Toolbar>
     }
 }
 
+/**
+ *
+ * Toolbar is a grouping component for buttons and other content.
+ *
+ * Demos:
+ *
+ * - [Toolbar](https://www.primefaces.org/primevue/showcase/#/toolbar)
+ *
+ */
 export default Toolbar;