@sciol/xyzen 0.3.6 → 0.3.8

package/dist/app/AppFullscreen.d.ts

@@ -2,4 +2,4 @@ export interface AppFullscreenProps {
     backendUrl?: string;
     showLlmProvider?: boolean;
 }
-export declare function AppFullscreen({ backendUrl, showLlmProvider, }: AppFullscreenProps): import('react').ReactPortal | null;
+export declare function AppFullscreen({ backendUrl, }: AppFullscreenProps): import('react').ReactPortal | null;

package/dist/app/explore/AgentExploreContent.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const AgentExploreContent: React.FC;
+export default AgentExploreContent;

package/dist/app/explore/AgentExploreTab.d.ts

@@ -0,0 +1,2 @@
+declare const AgentExploreTab: React.FC;
+export default AgentExploreTab;

package/dist/app/explore/McpExploreContent.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const McpExploreContent: React.FC;
+export default McpExploreContent;

package/dist/app/explore/McpExploreTab.d.ts

@@ -0,0 +1,2 @@
+declare const McpExploreTab: React.FC;
+export default McpExploreTab;

package/dist/components/animate-ui/components/buttons/button.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import { ButtonProps as ButtonPrimitiveProps } from '../../primitives/buttons/button';
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "outline" | "accent" | "destructive" | "secondary" | "ghost" | null | undefined;
+    variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | "accent" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type ButtonProps = ButtonPrimitiveProps & VariantProps<typeof buttonVariants>;

package/dist/components/animate-ui/components/buttons/github-stars.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import { GithubStarsProps } from '../../primitives/animate/github-stars';
+import { ButtonProps as ButtonPrimitiveProps } from '../../primitives/buttons/button';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "ghost" | "accent" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type GitHubStarsButtonProps = Omit<ButtonPrimitiveProps & GithubStarsProps, "asChild" | "children"> & VariantProps<typeof buttonVariants>;
+declare function GitHubStarsButton({ className, username, repo, value, delay, inView, inViewMargin, inViewOnce, variant, size, ...props }: GitHubStarsButtonProps): import("react/jsx-runtime").JSX.Element;
+export { GitHubStarsButton, type GitHubStarsButtonProps };

package/dist/components/animate-ui/components/headless/checkbox.d.ts

@@ -0,0 +1,11 @@
+import { motion } from 'motion/react';
+import { CheckboxProps as CheckboxPrimitiveProps } from '../../primitives/headless/checkbox';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const checkboxVariants: (props?: ({
+    variant?: "default" | "accent" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type CheckboxProps<TTag extends React.ElementType = typeof motion.button> = CheckboxPrimitiveProps<TTag> & VariantProps<typeof checkboxVariants>;
+declare function Checkbox<TTag extends React.ElementType = typeof motion.button>({ className, children, variant, size, ...props }: CheckboxProps<TTag>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox, type CheckboxProps };

package/dist/components/animate-ui/components/radix/dropdown-menu.d.ts

@@ -0,0 +1,37 @@
+import { DropdownMenuCheckboxItemProps as DropdownMenuCheckboxItemPrimitiveProps, DropdownMenuContentProps as DropdownMenuContentPrimitiveProps, DropdownMenuGroupProps as DropdownMenuGroupPrimitiveProps, DropdownMenuItemProps as DropdownMenuItemPrimitiveProps, DropdownMenuLabelProps as DropdownMenuLabelPrimitiveProps, DropdownMenuProps as DropdownMenuPrimitiveProps, DropdownMenuRadioGroupProps as DropdownMenuRadioGroupPrimitiveProps, DropdownMenuRadioItemProps as DropdownMenuRadioItemPrimitiveProps, DropdownMenuSeparatorProps as DropdownMenuSeparatorPrimitiveProps, DropdownMenuShortcutProps as DropdownMenuShortcutPrimitiveProps, DropdownMenuSubContentProps as DropdownMenuSubContentPrimitiveProps, DropdownMenuSubProps as DropdownMenuSubPrimitiveProps, DropdownMenuSubTriggerProps as DropdownMenuSubTriggerPrimitiveProps, DropdownMenuTriggerProps as DropdownMenuTriggerPrimitiveProps } from '../../primitives/radix/dropdown-menu';
+type DropdownMenuProps = DropdownMenuPrimitiveProps;
+declare function DropdownMenu(props: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuTriggerProps = DropdownMenuTriggerPrimitiveProps;
+declare function DropdownMenuTrigger(props: DropdownMenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuContentProps = DropdownMenuContentPrimitiveProps;
+declare function DropdownMenuContent({ sideOffset, className, children, ...props }: DropdownMenuContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuGroupProps = DropdownMenuGroupPrimitiveProps;
+declare function DropdownMenuGroup({ ...props }: DropdownMenuGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuItemProps = DropdownMenuItemPrimitiveProps & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+};
+declare function DropdownMenuItem({ className, inset, variant, disabled, ...props }: DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuCheckboxItemProps = DropdownMenuCheckboxItemPrimitiveProps;
+declare function DropdownMenuCheckboxItem({ className, children, checked, disabled, ...props }: DropdownMenuCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioGroupProps = DropdownMenuRadioGroupPrimitiveProps;
+declare function DropdownMenuRadioGroup(props: DropdownMenuRadioGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioItemProps = DropdownMenuRadioItemPrimitiveProps;
+declare function DropdownMenuRadioItem({ className, children, disabled, ...props }: DropdownMenuRadioItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuLabelProps = DropdownMenuLabelPrimitiveProps & {
+    inset?: boolean;
+};
+declare function DropdownMenuLabel({ className, inset, ...props }: DropdownMenuLabelProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSeparatorProps = DropdownMenuSeparatorPrimitiveProps;
+declare function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuShortcutProps = DropdownMenuShortcutPrimitiveProps;
+declare function DropdownMenuShortcut({ className, ...props }: DropdownMenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubProps = DropdownMenuSubPrimitiveProps;
+declare function DropdownMenuSub(props: DropdownMenuSubProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubTriggerProps = DropdownMenuSubTriggerPrimitiveProps & {
+    inset?: boolean;
+};
+declare function DropdownMenuSubTrigger({ disabled, className, inset, children, ...props }: DropdownMenuSubTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubContentProps = DropdownMenuSubContentPrimitiveProps;
+declare function DropdownMenuSubContent({ className, ...props }: DropdownMenuSubContentProps): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type DropdownMenuCheckboxItemProps, type DropdownMenuContentProps, type DropdownMenuGroupProps, type DropdownMenuItemProps, type DropdownMenuLabelProps, type DropdownMenuProps, type DropdownMenuRadioGroupProps, type DropdownMenuRadioItemProps, type DropdownMenuSeparatorProps, type DropdownMenuShortcutProps, type DropdownMenuSubContentProps, type DropdownMenuSubProps, type DropdownMenuSubTriggerProps, type DropdownMenuTriggerProps, };

package/dist/components/animate-ui/components/radix/tooltip.d.ts

@@ -0,0 +1,10 @@
+import { TooltipContentProps as TooltipContentPrimitiveProps, TooltipProps as TooltipPrimitiveProps, TooltipTriggerProps as TooltipTriggerPrimitiveProps } from '../../primitives/radix/tooltip';
+type TooltipProps = TooltipPrimitiveProps & {
+    delayDuration?: TooltipPrimitiveProps["delayDuration"];
+};
+declare function Tooltip({ delayDuration, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+type TooltipTriggerProps = TooltipTriggerPrimitiveProps;
+declare function TooltipTrigger({ ...props }: TooltipTriggerProps): import("react/jsx-runtime").JSX.Element;
+type TooltipContentProps = TooltipContentPrimitiveProps;
+declare function TooltipContent({ className, sideOffset, children, ...props }: TooltipContentProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipTrigger, type TooltipContentProps, type TooltipProps, type TooltipTriggerProps, };

package/dist/components/animate-ui/primitives/animate/github-stars.d.ts

@@ -0,0 +1,40 @@
+import { HTMLMotionProps } from 'motion/react';
+import { UseIsInViewOptions } from '../../../../hooks/use-is-in-view';
+import { WithAsChild } from './slot';
+import { SlidingNumberProps } from '../texts/sliding-number';
+import { ParticlesEffectProps } from '../effects/particles';
+import * as React from "react";
+type GithubStarsContextType = {
+    stars: number;
+    setStars: (stars: number) => void;
+    currentStars: number;
+    setCurrentStars: (stars: number) => void;
+    isCompleted: boolean;
+    isLoading: boolean;
+};
+declare const useGithubStars: () => GithubStarsContextType;
+type GithubStarsProps = WithAsChild<{
+    children: React.ReactNode;
+    username?: string;
+    repo?: string;
+    value?: number;
+    delay?: number;
+} & UseIsInViewOptions & HTMLMotionProps<"div">>;
+declare function GithubStars({ ref, children, username, repo, value, delay, inView, inViewMargin, inViewOnce, asChild, ...props }: GithubStarsProps): import("react/jsx-runtime").JSX.Element;
+type GithubStarsNumberProps = Omit<SlidingNumberProps, "number" | "fromNumber">;
+declare function GithubStarsNumber({ padStart, ...props }: GithubStarsNumberProps): import("react/jsx-runtime").JSX.Element;
+type GithubStarsIconProps<T extends React.ElementType> = {
+    icon: React.ReactElement<T>;
+    color?: string;
+    activeClassName?: string;
+} & React.ComponentProps<T>;
+declare function GithubStarsIcon<T extends React.ElementType>({ icon: Icon, color, activeClassName, className, ...props }: GithubStarsIconProps<T>): import("react/jsx-runtime").JSX.Element;
+type GithubStarsParticlesProps = ParticlesEffectProps & {
+    children: React.ReactElement;
+    size?: number;
+};
+declare function GithubStarsParticles({ children, size, style, ...props }: GithubStarsParticlesProps): import("react/jsx-runtime").JSX.Element;
+type GithubStarsLogoProps = React.SVGProps<SVGSVGElement>;
+declare function GithubStarsLogo(props: GithubStarsLogoProps): import("react/jsx-runtime").JSX.Element;
+export { GithubStars, GithubStarsNumber, GithubStarsIcon, GithubStarsParticles, GithubStarsLogo, useGithubStars, //eslint-disable-line
+type GithubStarsProps, type GithubStarsNumberProps, type GithubStarsIconProps, type GithubStarsParticlesProps, type GithubStarsLogoProps, type GithubStarsContextType, };

package/dist/components/animate-ui/primitives/effects/highlight.d.ts

@@ -88,5 +88,5 @@ type HighlightItemProps<T extends React.ElementType = "div"> = React.ComponentPr
     forceUpdateBounds?: boolean;
 };
 declare function HighlightItem<T extends React.ElementType>({ ref, as, children, id, value, className, style, transition, disabled, activeClassName, exitDelay, asChild, forceUpdateBounds, ...props }: HighlightItemProps<T>): any;
-export { Highlight, HighlightItem, useHighlight, // eslint-disable-line react-refresh/only-export-components
+export { Highlight, HighlightItem, useHighlight, //eslint-disable-line
 type HighlightItemProps, type HighlightProps, };

package/dist/components/animate-ui/primitives/effects/particles.d.ts

@@ -0,0 +1,25 @@
+import { HTMLMotionProps } from 'motion/react';
+import { WithAsChild } from '../animate/slot';
+import { UseIsInViewOptions } from '../../../../hooks/use-is-in-view';
+import * as React from "react";
+type Side = "top" | "bottom" | "left" | "right";
+type Align = "start" | "center" | "end";
+type ParticlesProps = WithAsChild<Omit<HTMLMotionProps<"div">, "children"> & {
+    animate?: boolean;
+    children: React.ReactNode;
+} & UseIsInViewOptions>;
+declare function Particles({ ref, animate, asChild, inView, inViewMargin, inViewOnce, children, style, ...props }: ParticlesProps): import("react/jsx-runtime").JSX.Element;
+type ParticlesEffectProps = Omit<HTMLMotionProps<"div">, "children"> & {
+    side?: Side;
+    align?: Align;
+    count?: number;
+    radius?: number;
+    spread?: number;
+    duration?: number;
+    holdDelay?: number;
+    sideOffset?: number;
+    alignOffset?: number;
+    delay?: number;
+};
+declare function ParticlesEffect({ side, align, count, radius, spread, duration, holdDelay, sideOffset, alignOffset, delay, transition, style, ...props }: ParticlesEffectProps): import("react/jsx-runtime").JSX.Element;
+export { Particles, ParticlesEffect, type ParticlesProps, type ParticlesEffectProps, };

package/dist/components/animate-ui/primitives/headless/checkbox.d.ts

@@ -0,0 +1,16 @@
+import { CheckboxProps as CheckboxPrimitiveProps } from '@headlessui/react';
+import { motion, HTMLMotionProps, SVGMotionProps } from 'motion/react';
+import * as React from "react";
+type CheckboxContextType = {
+    isChecked: boolean;
+    isIndeterminate: boolean;
+};
+declare const useCheckbox: () => CheckboxContextType;
+type CheckboxProps<TTag extends React.ElementType = typeof motion.button> = CheckboxPrimitiveProps<TTag> & Omit<HTMLMotionProps<"button">, "checked" | "onChange" | "defaultChecked" | "children"> & {
+    as?: TTag;
+};
+declare function Checkbox<TTag extends React.ElementType = typeof motion.button>({ children, ...props }: CheckboxProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type CheckboxIndicatorProps = SVGMotionProps<SVGSVGElement>;
+declare function CheckboxIndicator(props: CheckboxIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export { Checkbox, CheckboxIndicator, useCheckbox, //eslint-disable-line
+type CheckboxContextType, type CheckboxIndicatorProps, type CheckboxProps, };

package/dist/components/animate-ui/primitives/radix/dropdown-menu.d.ts

@@ -0,0 +1,57 @@
+import { HTMLMotionProps } from 'motion/react';
+import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
+import { HighlightItemProps, HighlightProps } from '../effects/highlight';
+import * as React from "react";
+type DropdownMenuContextType = {
+    isOpen: boolean;
+    setIsOpen: (o: boolean) => void;
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+};
+type DropdownMenuSubContextType = {
+    isOpen: boolean;
+    setIsOpen: (o: boolean) => void;
+};
+declare const useDropdownMenu: () => DropdownMenuContextType;
+declare const useDropdownMenuSub: () => DropdownMenuSubContextType;
+type DropdownMenuProps = React.ComponentProps<typeof DropdownMenuPrimitive.Root>;
+declare function DropdownMenu(props: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuTriggerProps = React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>;
+declare function DropdownMenuTrigger(props: DropdownMenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuPortalProps = React.ComponentProps<typeof DropdownMenuPrimitive.Portal>;
+declare function DropdownMenuPortal(props: DropdownMenuPortalProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuGroupProps = React.ComponentProps<typeof DropdownMenuPrimitive.Group>;
+declare function DropdownMenuGroup(props: DropdownMenuGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubProps = React.ComponentProps<typeof DropdownMenuPrimitive.Sub>;
+declare function DropdownMenuSub(props: DropdownMenuSubProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioGroupProps = React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>;
+declare function DropdownMenuRadioGroup(props: DropdownMenuRadioGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubTriggerProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuSubTrigger({ disabled, textValue, ...props }: DropdownMenuSubTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubContentProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>, "forceMount" | "asChild"> & Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Portal>, "forceMount"> & HTMLMotionProps<"div">;
+declare function DropdownMenuSubContent({ loop, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, sideOffset, alignOffset, avoidCollisions, collisionBoundary, collisionPadding, arrowPadding, sticky, hideWhenDetached, transition, style, container, ...props }: DropdownMenuSubContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuHighlightProps = Omit<HighlightProps, "controlledItems" | "enabled" | "hover"> & {
+    animateOnHover?: boolean;
+};
+declare function DropdownMenuHighlight({ transition, ...props }: DropdownMenuHighlightProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuContentProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Content>, "forceMount" | "asChild"> & Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Portal>, "forceMount"> & HTMLMotionProps<"div">;
+declare function DropdownMenuContent({ loop, onCloseAutoFocus, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, side, sideOffset, align, alignOffset, avoidCollisions, collisionBoundary, collisionPadding, arrowPadding, sticky, hideWhenDetached, transition, style, container, ...props }: DropdownMenuContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuHighlightItemProps = HighlightItemProps;
+declare function DropdownMenuHighlightItem(props: DropdownMenuHighlightItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuItemProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Item>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuItem({ disabled, onSelect, textValue, ...props }: DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuCheckboxItemProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuCheckboxItem({ checked, onCheckedChange, disabled, onSelect, textValue, ...props }: DropdownMenuCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioItemProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuRadioItem({ value, disabled, onSelect, textValue, ...props }: DropdownMenuRadioItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuLabelProps = React.ComponentProps<typeof DropdownMenuPrimitive.Label>;
+declare function DropdownMenuLabel(props: DropdownMenuLabelProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSeparatorProps = React.ComponentProps<typeof DropdownMenuPrimitive.Separator>;
+declare function DropdownMenuSeparator(props: DropdownMenuSeparatorProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuShortcutProps = React.ComponentProps<"span">;
+declare function DropdownMenuShortcut(props: DropdownMenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuItemIndicatorProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.ItemIndicator>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuItemIndicator(props: DropdownMenuItemIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuHighlight, DropdownMenuHighlightItem, DropdownMenuItem, DropdownMenuItemIndicator, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, useDropdownMenu, //eslint-disable-line
+useDropdownMenuSub, //eslint-disable-line
+type DropdownMenuCheckboxItemProps, type DropdownMenuContentProps, type DropdownMenuContextType, type DropdownMenuGroupProps, type DropdownMenuHighlightItemProps, type DropdownMenuHighlightProps, type DropdownMenuItemIndicatorProps, type DropdownMenuItemProps, type DropdownMenuLabelProps, type DropdownMenuPortalProps, type DropdownMenuProps, type DropdownMenuRadioGroupProps, type DropdownMenuRadioItemProps, type DropdownMenuSeparatorProps, type DropdownMenuShortcutProps, type DropdownMenuSubContentProps, type DropdownMenuSubContextType, type DropdownMenuSubProps, type DropdownMenuSubTriggerProps, type DropdownMenuTriggerProps, };

package/dist/components/animate-ui/primitives/radix/tooltip.d.ts

@@ -0,0 +1,21 @@
+import { HTMLMotionProps } from 'motion/react';
+import { Tooltip as TooltipPrimitive } from 'radix-ui';
+import * as React from "react";
+type TooltipContextType = {
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+};
+declare const useTooltip: () => TooltipContextType;
+type TooltipProviderProps = React.ComponentProps<typeof TooltipPrimitive.Provider>;
+declare function TooltipProvider(props: TooltipProviderProps): import("react/jsx-runtime").JSX.Element;
+type TooltipProps = React.ComponentProps<typeof TooltipPrimitive.Root>;
+declare function Tooltip(props: TooltipProps): import("react/jsx-runtime").JSX.Element;
+type TooltipTriggerProps = React.ComponentProps<typeof TooltipPrimitive.Trigger>;
+declare function TooltipTrigger(props: TooltipTriggerProps): import("react/jsx-runtime").JSX.Element;
+type TooltipPortalProps = Omit<React.ComponentProps<typeof TooltipPrimitive.Portal>, "forceMount">;
+declare function TooltipPortal(props: TooltipPortalProps): import("react/jsx-runtime").JSX.Element;
+type TooltipContentProps = Omit<React.ComponentProps<typeof TooltipPrimitive.Content>, "forceMount" | "asChild"> & HTMLMotionProps<"div">;
+declare function TooltipContent({ onEscapeKeyDown, onPointerDownOutside, side, sideOffset, align, alignOffset, avoidCollisions, collisionBoundary, collisionPadding, arrowPadding, sticky, hideWhenDetached, transition, ...props }: TooltipContentProps): import("react/jsx-runtime").JSX.Element;
+type TooltipArrowProps = React.ComponentProps<typeof TooltipPrimitive.Arrow>;
+declare function TooltipArrow(props: TooltipArrowProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipArrow, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, useTooltip, type TooltipArrowProps, type TooltipContentProps, type TooltipContextType, type TooltipPortalProps, type TooltipProps, type TooltipProviderProps, type TooltipTriggerProps, };

package/dist/components/animate-ui/primitives/texts/sliding-number.d.ts

@@ -0,0 +1,16 @@
+import { SpringOptions, HTMLMotionProps } from 'motion/react';
+import { UseIsInViewOptions } from '../../../../hooks/use-is-in-view';
+type SlidingNumberProps = Omit<HTMLMotionProps<"span">, "children"> & {
+    number: number;
+    fromNumber?: number;
+    onNumberChange?: (number: number) => void;
+    padStart?: boolean;
+    decimalSeparator?: string;
+    decimalPlaces?: number;
+    thousandSeparator?: string;
+    transition?: SpringOptions;
+    delay?: number;
+    initiallyStable?: boolean;
+} & UseIsInViewOptions;
+declare function SlidingNumber({ ref, number, fromNumber, onNumberChange, inView, inViewMargin, inViewOnce, padStart, decimalSeparator, decimalPlaces, thousandSeparator, transition, delay, initiallyStable, ...props }: SlidingNumberProps): import("react/jsx-runtime").JSX.Element;
+export { SlidingNumber, type SlidingNumberProps };

package/dist/components/base/Badge.d.ts

@@ -1,7 +1,7 @@
 import { default as React } from 'react';
 interface BadgeProps {
     children: React.ReactNode;
-    variant?: "default" | "blue" | "green" | "yellow" | "red" | "gray";
+    variant?: "default" | "blue" | "green" | "yellow" | "red" | "gray" | "purple";
     size?: "sm" | "md";
     className?: string;
 }

package/dist/components/features/ExploreMcpCard.d.ts

@@ -0,0 +1,6 @@
+import { BuiltinMcpData, ExplorableMcpServer } from '../../types/mcp';
+import { default as React } from 'react';
+declare const ExplorerMcpCard: React.FC<{
+    mcp: ExplorableMcpServer<BuiltinMcpData>;
+}>;
+export default ExplorerMcpCard;

package/dist/components/features/ExploreMcpListItem.d.ts

@@ -0,0 +1,6 @@
+import { BuiltinMcpData, ExplorableMcpServer } from '../../types/mcp';
+import { default as React } from 'react';
+declare const ExploreMcpListItem: React.FC<{
+    mcp: ExplorableMcpServer<BuiltinMcpData>;
+}>;
+export default ExploreMcpListItem;

package/dist/components/layouts/XyzenAgent.d.ts

@@ -10,7 +10,7 @@ export type Agent = {
     user_id: string;
     require_tool_confirmation?: boolean;
     provider_id?: string | null;
-    agent_type: "regular" | "graph" | "builtin";
+    agent_type: "regular" | "graph" | "builtin" | "system";
     avatar?: string | null;
     tags?: string[] | null;
     model?: string | null;
@@ -21,6 +21,8 @@ export type Agent = {
     state_schema?: Record<string, unknown>;
     node_count?: number;
     edge_count?: number;
+    is_published?: boolean;
+    is_official?: boolean;
 };
 interface XyzenAgentProps {
     systemAgentType?: "chat" | "workshop" | "all";

package/dist/components/ui/3d-card.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+export declare const CardContainer: ({ children, className, containerClassName, }: {
+    children?: React.ReactNode;
+    className?: string;
+    containerClassName?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const CardBody: ({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const CardItem: ({ as: Tag, children, className, translateX, translateY, translateZ, rotateX, rotateY, rotateZ, ...rest }: {
+    as?: React.ElementType;
+    children: React.ReactNode;
+    className?: string;
+    translateX?: number | string;
+    translateY?: number | string;
+    translateZ?: number | string;
+    rotateX?: number | string;
+    rotateY?: number | string;
+    rotateZ?: number | string;
+    [key: string]: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useMouseEnter: () => [boolean, React.Dispatch<React.SetStateAction<boolean>>];

package/dist/components/ui/3d-pin.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export declare const PinContainer: ({ children, title, href, className, containerClassName, }: {
+    children: React.ReactNode;
+    title?: string;
+    href?: string;
+    className?: string;
+    containerClassName?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const PinPerspective: ({ title, href, }: {
+    title?: string;
+    href?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/background-boxes.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export declare const BoxesCore: ({ className, ...rest }: {
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const Boxes: React.MemoExoticComponent<({ className, ...rest }: {
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/ui/background-gradient-animation.d.ts

@@ -0,0 +1,16 @@
+export declare const BackgroundGradientAnimation: ({ gradientBackgroundStart, gradientBackgroundEnd, firstColor, secondColor, thirdColor, fourthColor, fifthColor, pointerColor, size, blendingValue, children, className, interactive, containerClassName, }: {
+    gradientBackgroundStart?: string;
+    gradientBackgroundEnd?: string;
+    firstColor?: string;
+    secondColor?: string;
+    thirdColor?: string;
+    fourthColor?: string;
+    fifthColor?: string;
+    pointerColor?: string;
+    size?: string;
+    blendingValue?: string;
+    children?: React.ReactNode;
+    className?: string;
+    interactive?: boolean;
+    containerClassName?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/bento-grid.d.ts

@@ -0,0 +1,11 @@
+export declare const BentoGrid: ({ className, children, }: {
+    className?: string;
+    children?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const BentoGridItem: ({ className, title, description, header, icon, }: {
+    className?: string;
+    title?: string | React.ReactNode;
+    description?: string | React.ReactNode;
+    header?: React.ReactNode;
+    icon?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/components/ui/layout-text-flip.d.ts

@@ -0,0 +1,5 @@
+export declare const LayoutTextFlip: ({ text, words, duration, }: {
+    text: string;
+    words: string[];
+    duration?: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/pagination.d.ts

@@ -0,0 +1,13 @@
+import { Button } from './button';
+import * as React from "react";
+declare function Pagination({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+declare function PaginationItem({ ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<React.ComponentProps<typeof Button>, "size"> & React.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationNext({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/components/ui/shooting-stars.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface ShootingStarsProps {
+    minSpeed?: number;
+    maxSpeed?: number;
+    minDelay?: number;
+    maxDelay?: number;
+    starColor?: string;
+    trailColor?: string;
+    starWidth?: number;
+    starHeight?: number;
+    className?: string;
+}
+export declare const ShootingStars: React.FC<ShootingStarsProps>;
+export {};

package/dist/components/ui/spotlight-new.d.ts

@@ -0,0 +1,13 @@
+type SpotlightProps = {
+    gradientFirst?: string;
+    gradientSecond?: string;
+    gradientThird?: string;
+    translateY?: number;
+    width?: number;
+    height?: number;
+    smallWidth?: number;
+    duration?: number;
+    xOffset?: number;
+};
+export declare const Spotlight: ({ gradientFirst, gradientSecond, gradientThird, translateY, width, height, smallWidth, duration, xOffset, }?: SpotlightProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/hooks/use-data-state.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+type DataStateValue = string | boolean | null;
+declare function useDataState<T extends HTMLElement = HTMLElement>(key: string, forwardedRef?: React.Ref<T | null>, onChange?: (value: DataStateValue) => void): [DataStateValue, React.RefObject<T | null>];
+export { useDataState, type DataStateValue };

package/dist/hooks/use-is-in-view.d.ts

@@ -0,0 +1,12 @@
+import { UseInViewOptions } from 'motion/react';
+import * as React from "react";
+interface UseIsInViewOptions {
+    inView?: boolean;
+    inViewOnce?: boolean;
+    inViewMargin?: UseInViewOptions["margin"];
+}
+declare function useIsInView<T extends HTMLElement = HTMLElement>(ref: React.Ref<T>, options?: UseIsInViewOptions): {
+    ref: React.RefObject<T | null>;
+    isInView: boolean;
+};
+export { useIsInView, type UseIsInViewOptions };

package/dist/lib/animations.d.ts

@@ -0,0 +1,48 @@
+import { Variants } from 'framer-motion';
+/**
+ * Common animation variants for Framer Motion
+ * @module animations
+ */
+export declare const fadeIn: Variants;
+export declare const fadeOut: Variants;
+export declare const itemVariants: Variants;
+export declare const itemSlideLeft: Variants;
+export declare const itemSlideRight: Variants;
+export declare const containerVariants: Variants;
+export declare const containerFast: Variants;
+export declare const containerSlow: Variants;
+export declare const scaleIn: Variants;
+export declare const scaleOut: Variants;
+export declare const cardHover: {
+    scale: number;
+    transition: {
+        duration: number;
+    };
+};
+export declare const cardTap: {
+    scale: number;
+    transition: {
+        duration: number;
+    };
+};
+export declare const modalBackdrop: Variants;
+export declare const modalContent: Variants;
+export declare const slideInFromTop: Variants;
+export declare const slideInFromBottom: Variants;
+export declare const slideInFromLeft: Variants;
+export declare const slideInFromRight: Variants;
+export declare const pageTransition: Variants;
+/**
+ * Create a custom stagger container with specific timing
+ */
+export declare const createStaggerContainer: (staggerChildren?: number, delayChildren?: number) => Variants;
+/**
+ * Create a custom item variant with specific offset
+ */
+export declare const createItemVariant: (offset?: {
+    x?: number;
+    y?: number;
+}, springConfig?: {
+    stiffness?: number;
+    damping?: number;
+}) => Variants;

package/dist/marketplace/components/McpActivationProgress.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { McpActivationProgress } from '../types/bohrium';
+interface McpActivationProgressProps {
+    progress: McpActivationProgress;
+    onRetry?: () => void;
+    onClose?: () => void;
+    className?: string;
+}
+declare const McpActivationProgressComponent: React.FC<McpActivationProgressProps>;
+export default McpActivationProgressComponent;

package/dist/marketplace/components/McpServerCard.d.ts

@@ -0,0 +1,9 @@
+import { ExplorableMcpServer } from '../../types/mcp';
+import { default as React } from 'react';
+interface McpServerCardProps {
+    server: ExplorableMcpServer;
+    isStarred?: boolean;
+    onClick?: () => void;
+}
+declare const McpServerCard: React.FC<McpServerCardProps>;
+export default McpServerCard;

package/dist/marketplace/components/McpServerDetail.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface McpServerDetailProps {
+    appKey: string;
+    onBack?: () => void;
+}
+declare const McpServerDetail: React.FC<McpServerDetailProps>;
+export default McpServerDetail;

package/dist/marketplace/components/UnifiedMcpMarketList.d.ts

@@ -0,0 +1,8 @@
+import { ExplorableMcpServer } from '../../types/mcp';
+import { default as React } from 'react';
+interface UnifiedMcpMarketListProps {
+    builtinServers: ExplorableMcpServer[];
+    onSelectServer?: (server: ExplorableMcpServer) => void;
+}
+declare const UnifiedMcpMarketList: React.FC<UnifiedMcpMarketListProps>;
+export default UnifiedMcpMarketList;