@declarion/react 0.1.0

package/dist-lib/components/fields/StringField.d.ts

@@ -0,0 +1,2 @@
+import type { FieldRendererProps } from "./index";
+export declare function StringField({ value, mode, onChange }: FieldRendererProps): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/fields/StructureField.d.ts

@@ -0,0 +1,2 @@
+import type { FieldRendererProps } from "./index";
+export declare function StructureField(props: FieldRendererProps): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/fields/TextField.d.ts

@@ -0,0 +1,2 @@
+import type { FieldRendererProps } from "./index";
+export declare function TextField({ field, value, mode, onChange }: FieldRendererProps): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/fields/TimestampField.d.ts

@@ -0,0 +1,2 @@
+import type { FieldRendererProps } from "./index";
+export declare function TimestampField({ field, value, mode, onChange }: FieldRendererProps): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/fields/UrlField.d.ts

@@ -0,0 +1,2 @@
+import type { FieldRendererProps } from "./index";
+export declare function UrlField({ field, value, mode, onChange }: FieldRendererProps): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/fields/index.d.ts

@@ -0,0 +1,16 @@
+import type { EntityField } from "@/types/schema";
+export type RefsMap = Record<string, Record<string, Record<string, unknown>>>;
+export interface FieldRendererProps {
+    field: EntityField;
+    fieldName: string;
+    value: unknown;
+    mode: "display" | "edit";
+    onChange?: (value: unknown) => void;
+    record?: Record<string, unknown>;
+    refs?: RefsMap;
+}
+type FieldRenderer = React.ComponentType<FieldRendererProps>;
+export declare function renderField(props: FieldRendererProps): React.ReactNode;
+export declare function getFieldRenderer(type: string): FieldRenderer;
+export declare function hasFieldRenderer(key: string): boolean;
+export {};

package/dist-lib/components/filters/FilterChips.d.ts

@@ -0,0 +1,16 @@
+import { type FilterNode } from "@/lib/filters";
+interface FilterChipsProps {
+    filters: FilterNode[];
+    onRemove: (field: string) => void;
+    onClearAll: () => void;
+    onChipClick?: () => void;
+    /** Resolve field name to display label */
+    fieldLabel?: (field: string) => string;
+}
+/**
+ * FilterChips shows active filters as compact chips between toolbar and table.
+ * Simple mode: flat chips. OR mode: grouped chips.
+ * Zero active filters = hidden (zero height).
+ */
+export declare function FilterChips({ filters, onRemove, onClearAll, onChipClick, fieldLabel, }: FilterChipsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/filters/FilterDrawer.d.ts

@@ -0,0 +1,27 @@
+import { type FilterNode, type FilterOp } from "@/lib/filters";
+export interface FilterFieldMeta {
+    code: string;
+    label: string;
+    type: "string" | "enum" | "int" | "float" | "date" | "timestamp" | "bool" | "ref" | "status" | "property" | string;
+    operators: FilterOp[];
+    /** Enum values for enum/status fields. */
+    options?: {
+        value: string;
+        label: string;
+        color?: string;
+    }[];
+}
+interface FilterDrawerProps {
+    open: boolean;
+    onClose: () => void;
+    filters: FilterNode[];
+    onApply: (filters: FilterNode[]) => void;
+    availableFields: FilterFieldMeta[];
+}
+/**
+ * FilterDrawer - right-side panel with progressive disclosure.
+ * Level 1: flat AND conditions (default).
+ * Level 2: OR groups when "Add OR group" is clicked.
+ */
+export declare function FilterDrawer({ open, onClose, filters, onApply, availableFields, }: FilterDrawerProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/layout/Layout.d.ts

@@ -0,0 +1 @@
+export declare function Layout(): import("react/jsx-runtime").JSX.Element | null;

package/dist-lib/components/layout/Sidebar.d.ts

@@ -0,0 +1 @@
+export declare function Sidebar(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/layout/TabBar.d.ts

@@ -0,0 +1 @@
+export declare function TabBar(): import("react/jsx-runtime").JSX.Element | null;

package/dist-lib/components/layout/ThemeToggle.d.ts

@@ -0,0 +1 @@
+export declare function ThemeToggle(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/layout/TopBar.d.ts

@@ -0,0 +1 @@
+export declare function TopBar(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/pages/AdminCatalogPage.d.ts

@@ -0,0 +1 @@
+export declare function AdminCatalogPage(): import("react/jsx-runtime").JSX.Element | null;

package/dist-lib/components/pages/LoginPage.d.ts

@@ -0,0 +1 @@
+export declare function LoginPage(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/pages/NotFoundPage.d.ts

@@ -0,0 +1 @@
+export declare function NotFoundPage(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/pages/SSOCallbackPage.d.ts

@@ -0,0 +1 @@
+export declare function SSOCallbackPage(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/pages/SignupPage.d.ts

@@ -0,0 +1 @@
+export declare function SignupPage(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/pages/SmartDetailPage.d.ts

@@ -0,0 +1,5 @@
+interface SmartDetailPageProps {
+    screenCode: string;
+}
+export declare function SmartDetailPage({ screenCode }: SmartDetailPageProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/pages/SmartListPage.d.ts

@@ -0,0 +1,5 @@
+interface SmartListPageProps {
+    screenCode: string;
+}
+export declare function SmartListPage({ screenCode }: SmartListPageProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/pages/SmartRecordListPage.d.ts

@@ -0,0 +1,5 @@
+interface SmartRecordListPageProps {
+    screenCode: string;
+}
+export declare function SmartRecordListPage({ screenCode }: SmartRecordListPageProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/shared/ActionButton.d.ts

@@ -0,0 +1,24 @@
+import type { Action } from "@/types/schema";
+interface ActionButtonProps {
+    actionCode: string;
+    action: Action;
+    entityCode?: string;
+    /** Selected object IDs (for single/batch scope). */
+    objectIds?: string[];
+    /** Current row data for condition evaluation (single row context). */
+    row?: Record<string, unknown>;
+    /** Variant for the button. */
+    variant?: "default" | "outline" | "ghost" | "secondary";
+    /** Size for the button. */
+    size?: "default" | "sm" | "icon";
+    /** Called after action execution succeeds. */
+    onSuccess?: () => void;
+    /** Called when a batch action starts executing. */
+    onBatchStart?: (count: number) => void;
+    /** Called when a batch action fails. */
+    onBatchError?: (count: number) => void;
+    /** Called when a batch action partially succeeds (some items failed/skipped). */
+    onBatchPartial?: (count: number, successIds?: string[]) => void;
+}
+export declare function ActionButton({ actionCode, action, entityCode, objectIds, row, variant, size, onSuccess, onBatchStart, onBatchError, onBatchPartial, }: ActionButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/ActionConfirmDialog.d.ts

@@ -0,0 +1,10 @@
+interface ActionConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    actionName: string;
+    message: string;
+    onConfirm: () => void;
+    isPending: boolean;
+}
+export declare function ActionConfirmDialog({ open, onOpenChange, actionName, message, onConfirm, isPending, }: ActionConfirmDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/ActionDialog.d.ts

@@ -0,0 +1,22 @@
+import type { Action } from "@/types/schema";
+interface ActionDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    action: Action;
+    actionName: string;
+    onSubmit: (params: Record<string, unknown>) => void;
+    isPending: boolean;
+    /**
+     * Target record for default-value prefill via the `$row.<field>` template
+     * syntax. When a param default is a string literal `$row.foo`, the dialog
+     * substitutes `row.foo` at open time. For batch invocations on a list
+     * page, pass the first selected row (or omit - callers that invoke the
+     * action without a single-row context simply don't get row prefills).
+     *
+     * The substitution is client-side only. The server ignores template
+     * syntax - it only sees the concrete value the admin submits.
+     */
+    row?: Record<string, unknown>;
+}
+export declare function ActionDialog({ open, onOpenChange, action, actionName, onSubmit, isPending, row, }: ActionDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/ActionResultDialog.d.ts

@@ -0,0 +1,18 @@
+export interface DisplayField {
+    label: string;
+    value: string;
+    copyable?: boolean;
+    monospace?: boolean;
+}
+export interface ActionDisplayResult {
+    title?: string;
+    message?: string;
+    fields?: DisplayField[];
+}
+interface ActionResultDialogProps {
+    open: boolean;
+    onClose: () => void;
+    display: ActionDisplayResult;
+}
+export declare function ActionResultDialog({ open, onClose, display }: ActionResultDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/AssociationTabs.d.ts

@@ -0,0 +1,9 @@
+import type { AssociationDef, Schema } from "@/types/schema";
+interface AssociationTabsProps {
+    entityCode: string;
+    recordId: string;
+    associations: Record<string, AssociationDef>;
+    schema: Schema;
+}
+export declare function AssociationTabs({ entityCode, recordId, associations, schema, }: AssociationTabsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/shared/BatchActionProgress.d.ts

@@ -0,0 +1,18 @@
+interface BatchActionProgressProps {
+    /** Number of items being processed. */
+    count: number;
+    /** Whether the action is currently executing. */
+    isPending: boolean;
+    /** Whether the last execution succeeded. */
+    isSuccess?: boolean;
+    /** Whether the last execution errored. */
+    isError?: boolean;
+    /** Whether the last execution partially succeeded (some items failed/skipped). */
+    isPartial?: boolean;
+}
+/**
+ * Inline progress indicator for batch actions.
+ * Shows selected count, a spinner during execution, and success/error/partial state.
+ */
+export declare function BatchActionProgress({ count, isPending, isSuccess, isError, isPartial, }: BatchActionProgressProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/shared/ConfirmDialog.d.ts

@@ -0,0 +1,11 @@
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description: string;
+    confirmLabel?: string;
+    onConfirm: () => void;
+    destructive?: boolean;
+}
+export declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel, onConfirm, destructive, }: ConfirmDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/DynamicIcon.d.ts

@@ -0,0 +1,6 @@
+import type { LucideProps } from "lucide-react";
+interface DynamicIconProps extends LucideProps {
+    name: string;
+}
+export declare function DynamicIcon({ name, ...props }: DynamicIconProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist-lib/components/shared/EmptyState.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+interface EmptyStateProps {
+    icon?: string;
+    title: string;
+    description?: string;
+    action?: ReactNode;
+}
+export declare function EmptyState({ icon, title, description, action }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/ErrorBoundary.d.ts

@@ -0,0 +1,22 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+interface Props {
+    children: ReactNode;
+    /** Optional fallback UI. Defaults to a centered error card with retry button. */
+    fallback?: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * Catches JavaScript errors in child components and renders a fallback UI
+ * instead of crashing the entire app.
+ */
+export declare class ErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    handleRetry: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist-lib/components/shared/LoadingSkeleton.d.ts

@@ -0,0 +1,5 @@
+export declare function TableSkeleton({ rows, cols }: {
+    rows?: number;
+    cols?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DetailSkeleton(): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/shared/PageHeader.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+interface PageHeaderProps {
+    title: string;
+    backTo?: string;
+    actions?: ReactNode;
+}
+export declare function PageHeader({ title, backTo, actions }: PageHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/RowActionItem.d.ts

@@ -0,0 +1,11 @@
+import type { Action } from "@/types/schema";
+interface RowActionItemProps {
+    actionCode: string;
+    action: Action;
+    entityCode?: string;
+    objectId: string;
+    row: Record<string, unknown>;
+    onSuccess?: () => void;
+}
+export declare function RowActionItem({ actionCode, action, entityCode, objectId, row, onSuccess, }: RowActionItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/shared/StatusGroupsDisplay.d.ts

@@ -0,0 +1,11 @@
+import type { StatusGroupDef } from "@/types/schema";
+import type { StatusInfo } from "@/types/api";
+interface StatusGroupsDisplayProps {
+    statusGroups: Record<string, StatusGroupDef>;
+    objectStatuses: StatusInfo[] | undefined;
+    onSetStatus: (groupCode: string, statusCode: string) => void;
+    isPending: boolean;
+    mode?: "display" | "edit";
+}
+export declare function StatusGroupsDisplay({ statusGroups, objectStatuses, onSetStatus, isPending, mode, }: StatusGroupsDisplayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/components/ui/alert-dialog.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function AlertDialogHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist-lib/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+    color?: string;
+}
+declare function Badge({ className, variant, color, style, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "ghost" | "default" | "destructive" | "outline" | "secondary" | null | undefined;
+    size?: "icon" | "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/dist-lib/components/ui/dialog.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function DialogHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogClose, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist-lib/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,24 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function DropdownMenuShortcut({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist-lib/components/ui/input.d.ts

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

package/dist-lib/components/ui/label.d.ts

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

package/dist-lib/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+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 SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & 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, SelectItem, SelectLabel, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist-lib/components/ui/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist-lib/components/ui/skeleton.d.ts

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

package/dist-lib/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-lib/components/ui/textarea.d.ts

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

package/dist-lib/components/views/ViewSwitcher.d.ts

@@ -0,0 +1,27 @@
+export interface ViewItem {
+    /** UUID for DB views, code string for system views */
+    id: string;
+    name: Record<string, string>;
+    icon?: string;
+    source: "system" | "personal" | "shared";
+    is_default?: boolean;
+    filters?: unknown[];
+    columns?: string[];
+    sort?: string;
+}
+interface ViewSwitcherProps {
+    views: ViewItem[];
+    activeViewId: string | null;
+    isDirty: boolean;
+    onSelect: (view: ViewItem) => void;
+    onSave?: () => void;
+    onSaveAs?: () => void;
+    onSetDefault?: (viewId: string) => void;
+}
+/**
+ * ViewSwitcher - dropdown at the top of list pages.
+ * Shows system views (presets) + personal/shared DB views.
+ * "Save View" button appears when dirty.
+ */
+export declare function ViewSwitcher({ views, activeViewId, isDirty, onSelect, onSave, onSaveAs, onSetDefault, }: ViewSwitcherProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/hooks/useAssociatedData.d.ts

@@ -0,0 +1,10 @@
+import type { V2ListResponse } from "@/types/api";
+/**
+ * useAssociatedData fetches associated (non-aggregate) child entity records
+ * with cursor-based pagination, search, and filter support.
+ *
+ * Uses useInfiniteQuery so that "Load more" accumulates pages rather than
+ * replacing data. The query key is compatible with the SSE invalidation
+ * predicate (index 0 = ENTITY_CHILDREN_KEY, index 3 = child entity code).
+ */
+export declare function useAssociatedData(parentEntity: string, parentId: string, entityCode: string, foreignKey: string, sort?: string, limit?: number, search?: string, filters?: Record<string, string>): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<V2ListResponse<Record<string, unknown>>, unknown>, Error>;

package/dist-lib/hooks/useAuth.d.ts

@@ -0,0 +1,21 @@
+export declare function useAuth(): {
+    user: import("..").AuthUser | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    activeTenant: import("..").Tenant | null;
+    tenants: import("..").Tenant[];
+    login: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, {
+        email: string;
+        password: string;
+    }, unknown>;
+    signup: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, {
+        email: string;
+        password: string;
+        displayName: string;
+    }, unknown>;
+    switchTenant: import("@tanstack/react-query").UseMutateFunction<import("..").LoginResponse, Error, string, unknown>;
+    logout: () => Promise<void>;
+    isLoginPending: boolean;
+    isSignupPending: boolean;
+    isSwitchingTenant: boolean;
+};

package/dist-lib/hooks/useChildrenData.d.ts

@@ -0,0 +1,3 @@
+import type { ListResponse } from "@/types/api";
+export declare const ENTITY_CHILDREN_KEY: "entity-children";
+export declare function useChildrenData(parentEntity: string, parentId: string, childCode: string, foreignKey: string | string[], sort?: string, limit?: number): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useColumns.d.ts

@@ -0,0 +1,13 @@
+/**
+ * useColumns manages visible columns via URL `columns` param.
+ * Falls back to screen defaults when no URL param is set.
+ */
+export declare function useColumns(availableColumns: string[], defaultColumns: string[]): {
+    visibleColumns: string[];
+    availableColumns: string[];
+    setColumns: (cols: string[]) => void;
+    resetToDefaults: () => void;
+    showAll: () => void;
+    isColumnVisible: (col: string) => boolean;
+    toggleColumn: (col: string) => void;
+};

package/dist-lib/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare function useDebounce<T>(value: T, delay: number): T;

package/dist-lib/hooks/useEntity.d.ts

@@ -0,0 +1,2 @@
+import type { Entity } from "@/types/schema";
+export declare function useEntity(entityCode: string | undefined): Entity | undefined;

package/dist-lib/hooks/useEntityData.d.ts

@@ -0,0 +1,2 @@
+import type { ListParams } from "@/types/api";
+export declare function useEntityData(entity: string | undefined, params: ListParams): import("@tanstack/react-query").UseQueryResult<import("@/types/api").ListResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useEntityItem.d.ts

@@ -0,0 +1,2 @@
+import type { PkValues } from "@/types/schema";
+export declare function useEntityItem(entity: string | undefined, pkValues: PkValues | string | undefined): import("@tanstack/react-query").UseQueryResult<import("..").DataResponse<Record<string, unknown>>, Error>;

package/dist-lib/hooks/useFilters.d.ts

@@ -0,0 +1,11 @@
+import { type FilterNode } from "@/lib/filters";
+/**
+ * useFilters reads/writes the JSON `filters` URL param.
+ * URL is the source of truth.
+ */
+export declare function useFilters(): {
+    filters: FilterNode[];
+    activeCount: number;
+    setFilters: (newFilters: FilterNode[]) => void;
+    clearFilters: () => void;
+};