@plexui/vue 0.0.0-stage → 0.1.1

package/dist/types/components/Toast/Toaster.d.ts

@@ -0,0 +1,61 @@
+import { type PropType } from "vue";
+import { type ToasterProps as SonnerToasterProps } from "vue-sonner";
+import "vue-sonner/style.css";
+/**
+ * Spread into any `toast(...)` options to get a shrink-to-fit, centered
+ * layout: `toast("Saved", compact)`, `toast.success("Done", { ...compact, description })`.
+ */
+export declare const compact: {
+    readonly class: string;
+};
+declare const ToasterComponent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** Where toasts anchor on the viewport. @default "top-center" */
+    position: {
+        type: PropType<SonnerToasterProps["position"]>;
+        default: string;
+    };
+    /** Default auto-dismiss duration in ms. @default 3000 */
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Distance from the viewport edge */
+    offset: PropType<SonnerToasterProps["offset"]>;
+    /** Gap between stacked toasts in px */
+    gap: NumberConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** Where toasts anchor on the viewport. @default "top-center" */
+    position: {
+        type: PropType<SonnerToasterProps["position"]>;
+        default: string;
+    };
+    /** Default auto-dismiss duration in ms. @default 3000 */
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Distance from the viewport edge */
+    offset: PropType<SonnerToasterProps["offset"]>;
+    /** Gap between stacked toasts in px */
+    gap: NumberConstructor;
+}>> & Readonly<{}>, {
+    position: ("top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center") | undefined;
+    duration: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type ToasterOwnProps = InstanceType<typeof ToasterComponent>["$props"];
+/** Toaster props plus the vue-sonner `Toaster` props it forwards. */
+export type ToasterProps = ToasterOwnProps & Omit<SonnerToasterProps, "position" | "duration" | "closeButton" | "offset" | "gap" | "theme" | "richColors" | "toastOptions" | "style">;
+/**
+ * Toast viewport. Every other vue-sonner `Toaster` prop (`expand`,
+ * `visible-toasts`, `hotkey`, `dir`, `swipe-directions`, ...) is forwarded,
+ * last, as React spreads `restProps`. Icon slots (`success-icon`, ...,
+ * `close-icon`) replace the default icons.
+ */
+export declare const Toaster: typeof ToasterComponent & {
+    new (): {
+        $props: ToasterProps;
+    };
+};
+export {};

package/dist/types/components/Toast/index.d.ts

@@ -0,0 +1,3 @@
+export { Toaster, compact, type ToasterProps } from "./Toaster.js";
+export { toast } from "./toast.js";
+export type { Action, ExternalToast, ToastT } from "vue-sonner";

package/dist/types/components/Toast/toast.d.ts

@@ -0,0 +1,2 @@
+import { toast as sonnerToast } from "vue-sonner";
+export declare const toast: typeof sonnerToast;

package/dist/types/components/Tooltip/CopyTooltip.d.ts

@@ -0,0 +1,80 @@
+import { type PropType } from "vue";
+import { type TooltipAlign, type TooltipSide } from "./Tooltip.js";
+/** Wraps a trigger (the default slot) and copies `copyValue` when it is pressed. */
+export declare const CopyTooltip: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** Value to copy to the clipboard */
+    copyValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Delay before the tooltip opens from the first interaction, in milliseconds. @default 150 */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred alignment against the trigger. @default "center" */
+    align: {
+        type: PropType<TooltipAlign>;
+        default: string;
+    };
+    /** Offset from the "start" or "end" alignment, in pixels. @default 0 */
+    alignOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred side of the trigger. @default "top" */
+    side: {
+        type: PropType<TooltipSide>;
+        default: string;
+    };
+    /** Distance from the trigger, in pixels. @default 5 */
+    sideOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /** The clipboard write settled; `copied` says whether it succeeded (React's `onCopy`). */
+    copy: (_copied: boolean) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** Value to copy to the clipboard */
+    copyValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Delay before the tooltip opens from the first interaction, in milliseconds. @default 150 */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred alignment against the trigger. @default "center" */
+    align: {
+        type: PropType<TooltipAlign>;
+        default: string;
+    };
+    /** Offset from the "start" or "end" alignment, in pixels. @default 0 */
+    alignOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred side of the trigger. @default "top" */
+    side: {
+        type: PropType<TooltipSide>;
+        default: string;
+    };
+    /** Distance from the trigger, in pixels. @default 5 */
+    sideOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onCopy?: ((_copied: boolean) => any) | undefined;
+}>, {
+    side: TooltipSide;
+    sideOffset: number;
+    align: TooltipAlign;
+    alignOffset: number;
+    openDelay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type CopyTooltipProps = InstanceType<typeof CopyTooltip>["$props"];

package/dist/types/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,322 @@
+import { type PropType, type VNode } from "vue";
+export type TooltipSide = "top" | "right" | "bottom" | "left";
+export type TooltipAlign = "start" | "center" | "end";
+export type TooltipGutterSize = "sm" | "md" | "lg";
+/**
+ * The content custom properties under Radix's names (`--radix-tooltip-*`,
+ * `--radix-popover-*`), which the shared CSS reads. They still point at the
+ * `--reka-popper-*` values Reka sets on its positioning wrapper.
+ */
+export declare const withRadixVariableNames: (style: unknown, part: string) => Record<string, unknown>;
+/** Low-level tooltip root (`Tooltip.Root` in React). Always controlled: bind `v-model:open`. */
+export declare const TooltipRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    /** Delay before the tooltip opens on hover, in milliseconds. @default 700 */
+    delayDuration: NumberConstructor;
+    /** Closes the tooltip as soon as the pointer leaves the trigger. @default false */
+    disableHoverableContent: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (_open: boolean) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    /** Delay before the tooltip opens on hover, in milliseconds. @default 700 */
+    delayDuration: NumberConstructor;
+    /** Closes the tooltip as soon as the pointer leaves the trigger. @default false */
+    disableHoverableContent: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:open"?: ((_open: boolean) => any) | undefined;
+}>, {
+    disableHoverableContent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Low-level trigger (`Tooltip.Trigger` in React). Renders its child with the
+ * tooltip wiring merged in; `as-child="false"` renders a `<button>` instead.
+ */
+export declare const TooltipTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** Merges into the child instead of rendering a `<button>`. @default true */
+    asChild: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** Merges into the child instead of rendering a `<button>`. @default true */
+    asChild: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** Low-level content (`Tooltip.Content` in React). `class` lands on the tooltip. */
+export declare const TooltipContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** `max-width` of the tooltip; `"none"` sizes it to a single line. @default 300 */
+    maxWidth: {
+        type: PropType<number | "none">;
+        default: number;
+    };
+    /** Short, 1-3 word tooltips, stylized inversely from normal tooltips. @default false */
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Whether the tooltip content responds to clicks */
+    clickable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Preferred side of the trigger. @default "top" */
+    side: PropType<TooltipSide>;
+    /** Distance from the trigger, in pixels. @default 5 */
+    sideOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred alignment against the trigger. @default "center" */
+    align: PropType<TooltipAlign>;
+    /** Offset from the "start" or "end" alignment, in pixels. @default 0 */
+    alignOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Gutter sizing inside the tooltip. @default "md" */
+    gutterSize: {
+        type: PropType<TooltipGutterSize>;
+        default: string;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** `max-width` of the tooltip; `"none"` sizes it to a single line. @default 300 */
+    maxWidth: {
+        type: PropType<number | "none">;
+        default: number;
+    };
+    /** Short, 1-3 word tooltips, stylized inversely from normal tooltips. @default false */
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Whether the tooltip content responds to clicks */
+    clickable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Preferred side of the trigger. @default "top" */
+    side: PropType<TooltipSide>;
+    /** Distance from the trigger, in pixels. @default 5 */
+    sideOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred alignment against the trigger. @default "center" */
+    align: PropType<TooltipAlign>;
+    /** Offset from the "start" or "end" alignment, in pixels. @default 0 */
+    alignOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Gutter sizing inside the tooltip. @default "md" */
+    gutterSize: {
+        type: PropType<TooltipGutterSize>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    compact: boolean;
+    gutterSize: TooltipGutterSize;
+    maxWidth: number | "none";
+    sideOffset: number;
+    alignOffset: number;
+    clickable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Optional trigger wrapper (`Tooltip.TriggerDecorator` in React) for content
+ * that is not accessible or visibly interactive on its own. Plain text is
+ * wrapped in a focusable `<span>`; an element child gets the props merged in.
+ */
+export declare const TooltipTriggerDecorator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** Applies `tabindex="0"` to the trigger. @default true */
+    focusable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** Applies `tabindex="0"` to the trigger. @default true */
+    focusable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    focusable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const TooltipComponent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * The content of the tooltip (or the `#content` slot). `null` renders no
+     * tooltip.
+     */
+    content: {
+        type: PropType<string | number | VNode | null>;
+        default: undefined;
+    };
+    /** `max-width` of the tooltip; `"none"` sizes it to a single line. @default 300 */
+    maxWidth: {
+        type: PropType<number | "none">;
+        default: number;
+    };
+    /** Forces the tooltip to remain open or closed */
+    forceOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Delay before the tooltip opens from the first interaction, in milliseconds. @default 150 */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** The tooltip has interactive content and stays open while hovered. @default false */
+    interactive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Short, 1-3 word tooltips, stylized inversely from normal tooltips. @default false */
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Keeps the tooltip open when the trigger is clicked right after it opened. @default false */
+    preventUnintentionalClickToClose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Preferred alignment against the trigger. @default "center" */
+    align: PropType<TooltipAlign>;
+    /** Offset from the "start" or "end" alignment, in pixels. @default 0 */
+    alignOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred side of the trigger. @default "top" */
+    side: PropType<TooltipSide>;
+    /** Distance from the trigger, in pixels. @default 5 */
+    sideOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Gutter sizing inside the tooltip. @default "md" */
+    gutterSize: {
+        type: PropType<TooltipGutterSize>;
+        default: string;
+    };
+    /** Class applied to the tooltip content */
+    contentClassName: StringConstructor;
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    pointerdown: (_event: PointerEvent) => true;
+    click: (_event: MouseEvent) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * The content of the tooltip (or the `#content` slot). `null` renders no
+     * tooltip.
+     */
+    content: {
+        type: PropType<string | number | VNode | null>;
+        default: undefined;
+    };
+    /** `max-width` of the tooltip; `"none"` sizes it to a single line. @default 300 */
+    maxWidth: {
+        type: PropType<number | "none">;
+        default: number;
+    };
+    /** Forces the tooltip to remain open or closed */
+    forceOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Delay before the tooltip opens from the first interaction, in milliseconds. @default 150 */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** The tooltip has interactive content and stays open while hovered. @default false */
+    interactive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Short, 1-3 word tooltips, stylized inversely from normal tooltips. @default false */
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Keeps the tooltip open when the trigger is clicked right after it opened. @default false */
+    preventUnintentionalClickToClose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Preferred alignment against the trigger. @default "center" */
+    align: PropType<TooltipAlign>;
+    /** Offset from the "start" or "end" alignment, in pixels. @default 0 */
+    alignOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Preferred side of the trigger. @default "top" */
+    side: PropType<TooltipSide>;
+    /** Distance from the trigger, in pixels. @default 5 */
+    sideOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Gutter sizing inside the tooltip. @default "md" */
+    gutterSize: {
+        type: PropType<TooltipGutterSize>;
+        default: string;
+    };
+    /** Class applied to the tooltip content */
+    contentClassName: StringConstructor;
+}>> & Readonly<{
+    onClick?: ((_event: MouseEvent) => any) | undefined;
+    onPointerdown?: ((_event: PointerEvent) => any) | undefined;
+}>, {
+    content: string | number | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null;
+    compact: boolean;
+    gutterSize: TooltipGutterSize;
+    interactive: boolean;
+    maxWidth: number | "none";
+    sideOffset: number;
+    alignOffset: number;
+    forceOpen: boolean;
+    openDelay: number;
+    preventUnintentionalClickToClose: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Tooltip for any trigger element (the default slot). Content comes from the
+ * `content` prop or the `#content` slot; `null` disables the tooltip.
+ */
+export declare const Tooltip: typeof TooltipComponent & {
+    Root: typeof TooltipRoot;
+    Content: typeof TooltipContent;
+    Trigger: typeof TooltipTrigger;
+    TriggerDecorator: typeof TooltipTriggerDecorator;
+};
+export type TooltipProps = InstanceType<typeof TooltipComponent>["$props"];
+export {};

package/dist/types/components/Tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { CopyTooltip, type CopyTooltipProps } from "./CopyTooltip.js";
+export { Tooltip, TooltipContent, TooltipRoot, TooltipTrigger, TooltipTriggerDecorator, type TooltipAlign, type TooltipGutterSize, type TooltipProps, type TooltipSide, } from "./Tooltip.js";

package/dist/types/components/Tooltip/slot.d.ts

@@ -0,0 +1,27 @@
+import { type VNode, type VNodeArrayChildren } from "vue";
+type Props = Record<string, unknown>;
+/**
+ * Radix's `composeEventHandlers`: runs the caller's handler(s), then `ours`
+ * unless one of them called `preventDefault()`.
+ */
+export declare const composeEventHandlers: <E extends Event>(theirs: unknown, ours: (event: E) => void) => (event: E) => void;
+/** Slot content without fragments, comments and whitespace-only text. */
+export declare const flattenSlot: (nodes: VNodeArrayChildren | undefined) => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[];
+/**
+ * The element a Radix slot clones: the first child, when it is an element or
+ * a component. React's Slot throws for a text child (radix-ui 1.8); this
+ * renders nothing instead and warns in development.
+ */
+export declare const firstElementChild: (nodes: VNodeArrayChildren | undefined) => VNode | undefined;
+/** Radix's `concatAriaDescribedby`: the ids of every value, once each, in order. */
+export declare const concatAriaDescribedby: (...values: unknown[]) => string | undefined;
+/**
+ * Clones `child` with `slotProps` merged in the way Radix's Slot does it: the
+ * child's own props win, classes are joined (slot first), styles are merged
+ * (child last), `aria-describedby` ids are joined (child first, radix-ui 1.8)
+ * and handlers both run, the child's first.
+ */
+export declare const mergeSlotProps: (child: VNode, slotProps: Props) => VNode;
+export {};

package/dist/types/components/Transition/Animate.d.ts

@@ -0,0 +1,68 @@
+import { type PropType } from "vue";
+import type { InitialTransitionDefinition, InsertMethod, TransitionDefinition } from "./shared.js";
+/** Port of packages/ui/src/components/Transition/Animate.tsx. */
+export declare const Animate: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** Determines the tag used by the container and wrapping elements. @default "span" */
+    as: {
+        type: PropType<"div" | "span">;
+        default: string;
+    };
+    /** Determines how new children are added to the children array */
+    insertMethod: PropType<InsertMethod>;
+    /** Determines if children should have an enter transition applied during mounting. @default true */
+    preventInitialTransition: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Class applied to the inner TransitionGroup */
+    transitionClassName: StringConstructor;
+    /** Styles applied to the enter transition */
+    enter: PropType<TransitionDefinition>;
+    /** Styles applied to the exit transition */
+    exit: PropType<TransitionDefinition>;
+    /** Styles applied before the enter transition occurs */
+    initial: PropType<InitialTransitionDefinition>;
+    /** Determines how transition states are positioned. @default "absolute" */
+    transitionPosition: {
+        type: PropType<"absolute" | "static">;
+        default: string;
+    };
+    /** Applies `will-change` to force animating elements to composite layers. Use with caution! */
+    forceCompositeLayer: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** Determines the tag used by the container and wrapping elements. @default "span" */
+    as: {
+        type: PropType<"div" | "span">;
+        default: string;
+    };
+    /** Determines how new children are added to the children array */
+    insertMethod: PropType<InsertMethod>;
+    /** Determines if children should have an enter transition applied during mounting. @default true */
+    preventInitialTransition: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** Class applied to the inner TransitionGroup */
+    transitionClassName: StringConstructor;
+    /** Styles applied to the enter transition */
+    enter: PropType<TransitionDefinition>;
+    /** Styles applied to the exit transition */
+    exit: PropType<TransitionDefinition>;
+    /** Styles applied before the enter transition occurs */
+    initial: PropType<InitialTransitionDefinition>;
+    /** Determines how transition states are positioned. @default "absolute" */
+    transitionPosition: {
+        type: PropType<"absolute" | "static">;
+        default: string;
+    };
+    /** Applies `will-change` to force animating elements to composite layers. Use with caution! */
+    forceCompositeLayer: BooleanConstructor;
+}>> & Readonly<{}>, {
+    as: "div" | "span";
+    preventInitialTransition: boolean;
+    forceCompositeLayer: boolean;
+    transitionPosition: "absolute" | "static";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type AnimateProps = InstanceType<typeof Animate>["$props"];

package/dist/types/components/Transition/AnimateLayout.d.ts

@@ -0,0 +1,84 @@
+import { type PropType } from "vue";
+import type { InitialTransitionDefinition, InsertMethod, LayoutTransitionDefinition, TransitionDefinition } from "./shared.js";
+/** Port of packages/ui/src/components/Transition/AnimateLayout.tsx. */
+export declare const AnimateLayout: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    as: {
+        type: PropType<"div" | "span">;
+        default: string;
+    };
+    insertMethod: PropType<InsertMethod>;
+    /** An initial height animation will almost never be correct. Consider carefully when overriding. @default true */
+    preventInitialTransition: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Determines if `overflow: hidden` is applied to the wrapper element */
+    hideOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Determines which side of the container the items will pin to during enter/exit. @default "start" */
+    itemAnchor: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+    /** Determines which property will be animated during transitions. @default "height" */
+    dimension: {
+        type: PropType<"width" | "height">;
+        default: string;
+    };
+    layoutEnter: PropType<LayoutTransitionDefinition>;
+    layoutExit: PropType<LayoutTransitionDefinition>;
+    layoutMove: PropType<LayoutTransitionDefinition>;
+    enter: PropType<TransitionDefinition>;
+    exit: PropType<TransitionDefinition>;
+    initial: PropType<InitialTransitionDefinition>;
+    /** Class applied to the inner TransitionGroup */
+    transitionClassName: StringConstructor;
+    forceCompositeLayer: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    as: {
+        type: PropType<"div" | "span">;
+        default: string;
+    };
+    insertMethod: PropType<InsertMethod>;
+    /** An initial height animation will almost never be correct. Consider carefully when overriding. @default true */
+    preventInitialTransition: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Determines if `overflow: hidden` is applied to the wrapper element */
+    hideOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Determines which side of the container the items will pin to during enter/exit. @default "start" */
+    itemAnchor: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+    /** Determines which property will be animated during transitions. @default "height" */
+    dimension: {
+        type: PropType<"width" | "height">;
+        default: string;
+    };
+    layoutEnter: PropType<LayoutTransitionDefinition>;
+    layoutExit: PropType<LayoutTransitionDefinition>;
+    layoutMove: PropType<LayoutTransitionDefinition>;
+    enter: PropType<TransitionDefinition>;
+    exit: PropType<TransitionDefinition>;
+    initial: PropType<InitialTransitionDefinition>;
+    /** Class applied to the inner TransitionGroup */
+    transitionClassName: StringConstructor;
+    forceCompositeLayer: BooleanConstructor;
+}>> & Readonly<{}>, {
+    as: "div" | "span";
+    preventInitialTransition: boolean;
+    forceCompositeLayer: boolean;
+    hideOverflow: boolean;
+    itemAnchor: "end" | "start";
+    dimension: "width" | "height";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type AnimateLayoutProps = InstanceType<typeof AnimateLayout>["$props"];