@genispace/geniapp 0.3.0 → 0.4.0

package/dist/components/internal/shared-ui/components/ui/help-tip.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+export interface HelpTipProps {
+    /** Optional bold heading rendered above the content */
+    title?: React.ReactNode;
+    /** Explanation body — can be long-form (rendered in a Popover, not a Tooltip) */
+    content: React.ReactNode;
+    /** External/help-center URL for the "Learn more" row */
+    moreHref?: string;
+    /** Click handler alternative to `moreHref` for the "Learn more" row */
+    onMore?: () => void;
+    /** Label for the "Learn more" row (i18n override) */
+    moreLabel?: string;
+    /** Accessible label for the trigger button (i18n override) */
+    label?: string;
+    /** Popover placement side */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Popover alignment relative to the trigger */
+    align?: 'start' | 'center' | 'end';
+    /** Extra classes for the trigger button */
+    className?: string;
+    /** Extra classes for the popover content */
+    contentClassName?: string;
+}
+/**
+ * HelpTip — small circled "?" affordance that opens a Popover with contextual help.
+ * Use next to field labels, section titles, and toolbar actions where the
+ * explanation may be longer than a one-line tooltip.
+ */
+export declare function HelpTip({ title, content, moreHref, onMore, moreLabel, label, side, align, className, contentClassName, }: HelpTipProps): React.JSX.Element;

package/dist/components/internal/shared-ui/components/ui/hint-notice.d.ts

@@ -0,0 +1,22 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const hintNoticeCardVariants: (props?: {
+    variant?: "info" | "neutral" | "warning";
+} & import('class-variance-authority/types').ClassProp) => string;
+export type HintNoticeVariant = NonNullable<VariantProps<typeof hintNoticeCardVariants>['variant']>;
+export interface HintNoticeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'>, VariantProps<typeof hintNoticeCardVariants> {
+    /** Optional heading above the body */
+    title?: React.ReactNode;
+    /** Body content */
+    children: React.ReactNode;
+    /** Extra classes for inner `CardContent` */
+    contentClassName?: string;
+    /** When false, hides the leading icon slot */
+    showIcon?: boolean;
+    /** Custom icon node; defaults to Info (or Warning triangle for `warning` variant) */
+    icon?: React.ReactNode;
+    /** Apply `whitespace-pre-line` to the body wrapper */
+    preserveWhitespace?: boolean;
+}
+export declare const HintNotice: React.ForwardRefExoticComponent<HintNoticeProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/internal/shared-ui/components/ui/index.d.ts

@@ -0,0 +1,6 @@
+export { ModalContainer, useModal, MODAL_SIZES, type ModalSize } from './modal-container';
+export { BaseModal, FormModal, ConfirmModal, ListModal } from './modal-templates';
+export { AlertDialog, AlertProvider, useAlert, useAlertDialog, type AlertType } from './alert-dialog';
+export * from './dialog';
+export * from './dialog-input';
+export * from './sheet';

package/dist/components/internal/shared-ui/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/components/internal/shared-ui/components/ui/label.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/components/internal/shared-ui/components/ui/modal-container.d.ts

@@ -0,0 +1,56 @@
+import * as React from "react";
+export declare const MODAL_SIZES: {
+    readonly sm: {
+        readonly width: "480px";
+        readonly maxHeight: "90vh";
+    };
+    readonly md: {
+        readonly width: "640px";
+        readonly maxHeight: "90vh";
+    };
+    readonly lg: {
+        readonly width: "896px";
+        readonly maxHeight: "90vh";
+    };
+    readonly xl: {
+        readonly width: "1000px";
+        readonly maxHeight: "90vh";
+    };
+    readonly wide: {
+        readonly width: "min(1152px, 95vw)";
+        readonly maxHeight: "90vh";
+    };
+    readonly full: {
+        readonly width: "95vw";
+        readonly maxHeight: "95vh";
+    };
+    readonly STANDARD: {
+        readonly width: "896px";
+        readonly maxHeight: "90vh";
+    };
+    readonly LARGE: {
+        readonly width: "min(1152px, 95vw)";
+        readonly maxHeight: "90vh";
+    };
+};
+export type ModalSize = keyof typeof MODAL_SIZES;
+interface ModalContainerProps {
+    size?: ModalSize;
+    isOpen: boolean;
+    onClose: () => void;
+    title?: React.ReactNode;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+    className?: string;
+    contentClassName?: string;
+    usePortal?: boolean;
+    children: React.ReactNode;
+}
+export declare const ModalContainer: React.FC<ModalContainerProps>;
+export declare const useModal: (initialOpen?: boolean) => {
+    isOpen: boolean;
+    openModal: () => void;
+    closeModal: () => void;
+    toggleModal: () => void;
+};
+export default ModalContainer;

package/dist/components/internal/shared-ui/components/ui/modal-templates.d.ts

@@ -0,0 +1,46 @@
+import { ModalSize } from './modal-container';
+import * as React from "react";
+interface BaseModalProps {
+    size?: ModalSize;
+    isOpen: boolean;
+    onClose: () => void;
+    title?: React.ReactNode;
+    className?: string;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+}
+export declare const BaseModal: React.FC<BaseModalProps>;
+interface FormModalProps extends Omit<BaseModalProps, 'footer'> {
+    onSubmit?: () => void;
+    onCancel?: () => void;
+    submitText?: string;
+    cancelText?: string;
+    submitDisabled?: boolean;
+    submitLoading?: boolean;
+    showFooter?: boolean;
+    customFooter?: React.ReactNode;
+}
+export declare const FormModal: React.FC<FormModalProps>;
+interface ConfirmModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    title?: React.ReactNode;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+    danger?: boolean;
+    loading?: boolean;
+}
+export declare const ConfirmModal: React.FC<ConfirmModalProps>;
+interface ListModalProps extends BaseModalProps {
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    onSearch?: (term: string) => void;
+    emptyMessage?: string;
+    loading?: boolean;
+}
+export declare const ListModal: React.FC<ListModalProps>;
+export {};

package/dist/components/internal/shared-ui/components/ui/multi-select.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export interface MultiSelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+export interface MultiSelectProps {
+    options: MultiSelectOption[];
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    maxDisplayCount?: number;
+    showClearButton?: boolean;
+    emptyText?: string;
+}
+export declare const MultiSelect: React.ForwardRefExoticComponent<MultiSelectProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/internal/shared-ui/components/ui/pagination.d.ts

@@ -0,0 +1,28 @@
+import { ButtonProps } from './button';
+import * as React from "react";
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, "size"> & React.ComponentProps<"a">;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/components/internal/shared-ui/components/ui/popover.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/dist/components/internal/shared-ui/components/ui/progress.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+export { Progress };

package/dist/components/internal/shared-ui/components/ui/radio-button-group.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+
+export interface RadioButtonOption {
+    label: string;
+    value: string;
+}
+export interface RadioButtonGroupProps {
+    options: RadioButtonOption[];
+    value?: string | string[];
+    onChange?: (value: string | string[]) => void;
+    label?: string;
+    multiple?: boolean;
+    defaultValue?: string | string[];
+    className?: string;
+    optionsClassName?: string;
+    getOptionClassName?: (option: RadioButtonOption, isSelected: boolean) => string;
+}
+export declare const RadioButtonGroup: React.FC<RadioButtonGroupProps>;

package/dist/components/internal/shared-ui/components/ui/radio-group.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { RadioGroup, RadioGroupItem };

package/dist/components/internal/shared-ui/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

package/dist/components/internal/shared-ui/components/ui/select.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ onValueChange, ...props }: React.ComponentPropsWithoutRef<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare namespace Select {
+    var displayName: string;
+}
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/components/internal/shared-ui/components/ui/separator.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+
+export interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/components/internal/shared-ui/components/ui/sheet.d.ts

@@ -0,0 +1,25 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+declare const Sheet: React.FC<SheetPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: {
+    side?: "left" | "right" | "bottom" | "top";
+} & import('class-variance-authority/types').ClassProp) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/components/internal/shared-ui/components/ui/sidebar-rail.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface SidebarRailProps {
+    collapsed: boolean;
+    onToggle: () => void;
+    show?: boolean;
+}
+export declare const SidebarRail: React.FC<SidebarRailProps>;
+export {};

package/dist/components/internal/shared-ui/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export { Skeleton };

package/dist/components/internal/shared-ui/components/ui/slider.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+interface SliderProps {
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    className?: string;
+    disabled?: boolean;
+}
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLDivElement>>;
+export { Slider };

package/dist/components/internal/shared-ui/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/components/internal/shared-ui/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/components/internal/shared-ui/components/ui/tabs.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare function Tabs({ onValueChange, ...props }: React.ComponentPropsWithoutRef<typeof TabsPrimitive.Root>): React.JSX.Element;
+declare namespace Tabs {
+    var displayName: string;
+}
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/components/internal/shared-ui/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/components/internal/shared-ui/components/ui/toast.d.ts

@@ -0,0 +1,21 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "destructive" | "success";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ToastProgressBarProps {
+    duration: number;
+    variant?: "default" | "destructive" | "success";
+    onComplete?: () => void;
+}
+declare const ToastProgressBar: React.ForwardRefExoticComponent<ToastProgressBarProps & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, ToastProgressBar, };

package/dist/components/internal/shared-ui/components/ui/toggle-group.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import('class-variance-authority/types').ClassProp) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

package/dist/components/internal/shared-ui/components/ui/toggle.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+declare const toggleVariants: (props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import('class-variance-authority/types').ClassProp) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

package/dist/components/internal/shared-ui/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/internal/shared-ui/components/ui/typography.d.ts

@@ -0,0 +1,15 @@
+interface TypographyProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+}
+export declare function H1({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function H2({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function H3({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function H4({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function P({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function Blockquote({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function InlineCode({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function Lead({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function Large({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function Small({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export declare function Muted({ children, className, ...props }: TypographyProps): import("react").JSX.Element;
+export {};

package/dist/components/internal/shared-ui/components/ui/underline-tabs.d.ts

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const UnderlineTabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const UnderlineTabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const underlineTabsTriggerVariants: (props?: {
+    variant?: "default" | "orange" | "brand";
+} & import('class-variance-authority/types').ClassProp) => string;
+declare const UnderlineTabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "orange" | "brand";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+declare const UnderlineTabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { UnderlineTabs, UnderlineTabsList, UnderlineTabsTrigger, UnderlineTabsContent, underlineTabsTriggerVariants, };

package/dist/components/internal/shared-ui/components/ui/view-mode-toggle.d.ts

@@ -0,0 +1,9 @@
+export type ViewMode = "grid" | "list";
+export interface ViewModeToggleProps {
+    mode: ViewMode;
+    onModeChange: (mode: ViewMode) => void;
+    className?: string;
+    gridAriaLabel?: string;
+    listAriaLabel?: string;
+}
+export declare function ViewModeToggle({ mode, onModeChange, className, gridAriaLabel, listAriaLabel, }: ViewModeToggleProps): import("react").JSX.Element;

package/dist/components/internal/shared-ui/context/AppHostContext.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+
+/**
+ * Optional context for GeniApps in non-iframe test harnesses. Iframe apps receive session/token
+ * and platform API host via `GENISPACE_SHELL_INIT` from the Shell (`API_BASE_URL`).
+ */
+export type AppHostContextValue = {
+    identifier: string | null;
+    pinnedVersion: string | null;
+};
+export declare const AppHostContext: import('react').Context<AppHostContextValue>;
+export declare function AppHostProvider({ value, children, }: {
+    value: AppHostContextValue;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useAppHost(): AppHostContextValue;

package/dist/components/internal/shared-ui/contexts/UserSettingsContext.d.ts

@@ -0,0 +1,23 @@
+import { default as React, ReactNode } from 'react';
+import { UserSettings, UserPreferences, UserSettingsApiClient } from '../hooks/useUserSettings';
+
+interface UserSettingsContextType {
+    settings: UserSettings | null;
+    loading: boolean;
+    error: string | null;
+    updateSettings: (updates: Partial<{
+        spaceId: string | null;
+        preferences: Partial<UserPreferences>;
+    }>) => Promise<void>;
+    refreshSettings: () => Promise<void>;
+}
+export interface UserSettingsProviderProps {
+    apiClient: UserSettingsApiClient;
+    user?: {
+        isLoggedIn?: boolean;
+    } | null;
+    children: ReactNode;
+}
+export declare const UserSettingsProvider: React.FC<UserSettingsProviderProps>;
+export declare const useUserSettingsContext: () => UserSettingsContextType;
+export {};