@nubase/frontend 0.1.2 → 0.1.5

package/dist/index.d.mts

@@ -1,154 +1,183 @@
 import * as React$1 from 'react';
-import React__default, { FC, ReactNode, RefObject } from 'react';
-import { ObjectSchema, Infer, BaseSchema, SchemaMetadata, ObjectShape, Layout, LayoutField, ObjectOutput, RequestSchema, InferRequestParams, InferRequestBody, InferResponseBody } from '@nubase/core';
-import { ReactFormExtendedApi, AnyFieldApi } from '@tanstack/react-form';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default, { ReactElement, FC, ReactNode, Key, RefObject } from 'react';
+import * as _nubase_core from '@nubase/core';
+import { ObjectSchema, Infer, ObjectShape, ObjectOutput, SchemaMetadata, Layout, ArraySchema, SeriesWidgetRequestSchema, ProportionalWidgetRequestSchema, KpiWidgetRequestSchema, TableWidgetRequestSchema, RequestSchema, InferRequestParams, InferRequestBody, InferResponseBody, BaseSchema } from '@nubase/core';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationOptions, UseQueryOptions, QueryClient } from '@tanstack/react-query';
+import { AnyRouter } from '@tanstack/react-router';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
-import { ColumnDef, SortingState, OnChangeFn } from '@tanstack/react-table';
-import { ClassValue } from 'clsx';
-
-interface DockProps {
-    center: React__default.ReactNode;
-    left?: React__default.ReactNode;
-    right?: React__default.ReactNode;
-    top?: React__default.ReactNode;
-    defaultLeftWidth?: number;
-    defaultRightWidth?: number;
-}
-declare const Dock: React__default.FC<DockProps>;
-
-type SchemaFormProps<TSchema extends ObjectSchema<any>, TData extends Infer<TSchema> = Infer<TSchema>> = {
-    schema: TSchema;
-    onSubmit: (data: TData) => void | Promise<void>;
-    submitText?: string;
-    className?: string;
-    /** Specify which layout to use (if schema has layouts defined) */
-    layoutName?: string;
-    /** Options for computed metadata behavior */
-    computedMetadata?: {
-        /** Debounce delay in milliseconds for computed metadata updates (default: 300ms) */
-        debounceMs?: number;
-    };
-};
-type SchemaFormRef<TSchema extends ObjectSchema<any>> = ReactFormExtendedApi<Infer<TSchema>, any, any, any, any, any, any, any, any, any>;
-declare const SchemaForm: <TSchema extends ObjectSchema<any>>(props: SchemaFormProps<TSchema> & {
-    ref?: React__default.Ref<SchemaFormRef<TSchema>>;
-}) => React__default.ReactElement;
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as RechartsPrimitive from 'recharts';
+import { Layout as Layout$1 } from 'react-grid-layout';
+export { Layout, LayoutItem } from 'react-grid-layout';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { ReactFormExtendedApi, AnyFieldApi } from '@tanstack/react-form';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { ZodError } from 'zod';
 
-interface FieldApi {
-    name: string;
-    state: {
-        value: any;
-        meta: {
-            isValidating: boolean;
-            isTouched: boolean;
-            isValid: boolean;
-            errors: (string | undefined)[];
-        };
-    };
-    handleChange: (value: any) => void;
-    handleBlur: () => void;
-}
-interface FormFieldRendererProps {
-    schema: BaseSchema<any>;
-    fieldState: FieldApi;
-    metadata: SchemaMetadata<any>;
+/**
+ * Interface for resource actions executor
+ */
+interface ResourceActionsExecutor {
+    execute: (action: ResourceAction, resourceType: string, selectedIds: (string | number)[]) => Promise<void>;
 }
-declare const FormFieldRenderer: React__default.FC<FormFieldRendererProps>;
 
-interface SchemaFormLayoutProps<TShape extends ObjectShape = any> {
-    layout: Layout<TShape>;
-    renderField: (field: LayoutField<TShape>) => React__default.ReactNode;
+/**
+ * Represents an authenticated user in the system.
+ * Applications can extend this with additional fields as needed.
+ */
+interface AuthenticatedUser {
+    id: number;
+    email: string;
+    displayName: string;
 }
-declare const SchemaFormLayout: <TShape extends ObjectShape = any>({ layout, renderField, }: SchemaFormLayoutProps<TShape>) => react_jsx_runtime.JSX.Element;
-
-declare const inputVariants: (props?: ({
-    hasError?: boolean | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface TextInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
-    hasError?: boolean;
+/**
+ * Authentication state managed by the AuthenticationController.
+ */
+interface AuthenticationState {
+    /** Current authentication status */
+    status: "loading" | "authenticated" | "unauthenticated";
+    /** The authenticated user, if any */
+    user: AuthenticatedUser | null;
+    /** Any error that occurred during authentication */
+    error: Error | null;
 }
-declare const TextInput: React__default.ForwardRefExoticComponent<TextInputProps & React__default.RefAttributes<HTMLInputElement>>;
-
-declare const searchInputVariants: (props?: ({
-    hasError?: boolean | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface SearchTextInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof searchInputVariants> {
-    hasError?: boolean;
+/**
+ * Listener function for authentication state changes.
+ */
+type AuthenticationStateListener = (state: AuthenticationState) => void;
+/**
+ * Login credentials for email/password authentication.
+ */
+interface LoginCredentials {
+    email: string;
+    password: string;
+    /** Workspace slug for path-based multi-workspace */
+    workspace?: string;
 }
-declare const SearchTextInput: React__default.ForwardRefExoticComponent<SearchTextInputProps & React__default.RefAttributes<HTMLInputElement>>;
-
-declare const labelVariants: (props?: ({
-    variant?: "default" | "required" | "muted" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface LabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
-    required?: boolean;
+/**
+ * Workspace info returned during two-step login.
+ */
+interface WorkspaceInfo {
+    id: number;
+    slug: string;
+    name: string;
 }
-declare const Label: React__default.ForwardRefExoticComponent<LabelProps & React__default.RefAttributes<HTMLLabelElement>>;
-
-declare const buttonVariants: (props?: ({
-    variant?: "primary" | "secondary" | "danger" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
-    asChild?: boolean;
+/**
+ * Response from login start (step 1 of two-step auth).
+ */
+interface LoginStartResponse {
+    /** Temporary token for completing login */
+    loginToken: string;
+    /** User's email */
+    email: string;
+    /** List of workspaces the user belongs to */
+    workspaces: WorkspaceInfo[];
 }
-declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
-
-interface FormControlProps extends React__default.HTMLAttributes<HTMLDivElement> {
-    label?: string;
-    hint?: string;
-    error?: string;
-    required?: boolean;
-    spacing?: "sm" | "md" | "lg";
-    children: React__default.ReactElement<{
-        id?: string;
-        hasError?: boolean;
-    }>;
-    field?: AnyFieldApi | FieldApi;
+/**
+ * Credentials for completing two-step login.
+ */
+interface LoginCompleteCredentials {
+    /** Temporary login token from login start */
+    loginToken: string;
+    /** Selected workspace slug */
+    workspace: string;
 }
-declare const FormControl: React__default.ForwardRefExoticComponent<FormControlProps & React__default.RefAttributes<HTMLDivElement>>;
-
-declare const selectVariants: (props?: ({
-    hasError?: boolean | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface SelectOption<T = unknown> {
-    value: T;
-    label: string;
-    disabled?: boolean;
+/**
+ * Signup credentials for creating new user and workspace.
+ */
+interface SignupCredentials {
+    workspace: string;
+    workspaceName: string;
+    email: string;
+    displayName: string;
+    password: string;
 }
-interface SelectProps<T = unknown> extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "onChange" | "onSelect">, VariantProps<typeof selectVariants> {
-    options: SelectOption<T>[];
-    value?: T;
-    onChange?: (value: T | null) => void;
-    onSelectionChange?: (selectedItem: SelectOption<T> | null) => void;
-    placeholder?: string;
-    disabled?: boolean;
-    hasError?: boolean;
-    loading?: boolean;
-    loadingMessage?: string;
-    emptyMessage?: string;
-    clearable?: boolean;
-    searchable?: boolean;
-    filterOptions?: (options: SelectOption<T>[], inputValue: string) => SelectOption<T>[];
+/**
+ * AuthenticationController interface.
+ *
+ * This is the core abstraction for authentication in Nubase applications.
+ * Applications implement this interface to provide their own authentication logic.
+ *
+ * The controller manages authentication state and provides methods for:
+ * - Logging in and out
+ * - Checking current authentication status
+ * - Subscribing to state changes
+ *
+ * Future extensibility:
+ * - Social login providers (Google, GitHub, etc.)
+ * - Forgot password / password reset
+ * - Two-factor authentication
+ * - Session management
+ */
+interface AuthenticationController {
+    /**
+     * Get the current authentication state.
+     */
+    getState(): AuthenticationState;
+    /**
+     * Subscribe to authentication state changes.
+     * Returns an unsubscribe function.
+     */
+    subscribe(listener: AuthenticationStateListener): () => void;
+    /**
+     * Log in with email and password.
+     * On success, updates state to authenticated.
+     * On failure, throws an error.
+     */
+    login(credentials: LoginCredentials): Promise<void>;
+    /**
+     * Log out the current user.
+     * Clears authentication state.
+     */
+    logout(): Promise<void>;
+    /**
+     * Initialize the authentication controller.
+     * Called by NubaseApp on startup to check for existing sessions.
+     * Should check for stored credentials/tokens and restore session if valid.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start the two-step login process (optional).
+     * Step 1: Validates credentials and returns list of workspaces user belongs to.
+     * If not implemented, falls back to single-step login.
+     */
+    loginStart?(credentials: {
+        email: string;
+        password: string;
+    }): Promise<LoginStartResponse>;
+    /**
+     * Complete the two-step login process (optional).
+     * Step 2: Select a workspace and complete authentication.
+     * If not implemented, falls back to single-step login.
+     */
+    loginComplete?(credentials: LoginCompleteCredentials): Promise<WorkspaceInfo>;
+    /**
+     * Sign up a new user and create a new workspace (optional).
+     * Creates both the workspace and the initial admin user.
+     */
+    signup?(credentials: SignupCredentials): Promise<void>;
 }
-declare const Select: React__default.ForwardRefExoticComponent<SelectProps<any> & React__default.RefAttributes<HTMLDivElement>>;
 
+type ModalSize = "sm" | "md" | "lg" | "xl" | "2xl" | "full";
 type ModalAlignment = "center" | "top";
-type ModalProps = {
-    open: boolean;
+type BaseModalFrameProps = {
     onClose: () => void;
-    children: ReactNode;
+};
+type ModalConfig = {
+    content: ReactElement<BaseModalFrameProps>;
+    size?: ModalSize;
     alignment?: ModalAlignment;
     showBackdrop?: boolean;
-    showCloseButton?: boolean;
-    className?: string;
-    size?: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
     zIndex?: number;
-    initialFocus?: React.RefObject<HTMLElement | null>;
+    onDismiss?: () => void;
+};
+type ModalInstance = {
+    id: string;
+    config: ModalConfig;
 };
-declare const Modal: FC<ModalProps>;
 
 type DialogProps = {
     open: boolean;
@@ -157,356 +186,874 @@ type DialogProps = {
     title?: string;
     children: ReactNode;
     size?: "sm" | "md" | "lg" | "xl" | "2xl";
-    showCloseButton?: boolean;
     className?: string;
     alignment?: ModalAlignment;
     confirmText?: string;
     cancelText?: string;
-    confirmVariant?: "primary" | "danger";
+    confirmVariant?: "default" | "destructive";
     showBackdrop?: boolean;
     zIndex?: number;
 };
 declare const Dialog: FC<DialogProps>;
 
-type DialogConfig = Omit<DialogProps, "open" | "onClose" | "onConfirm" | "children"> & {
+type DialogConfig = {
     title?: string;
     content: ReactNode;
     onConfirm?: () => void;
+    onCancel?: () => void;
+    size?: "sm" | "md" | "lg" | "xl" | "2xl";
+    className?: string;
+    alignment?: ModalAlignment;
+    confirmText?: string;
+    cancelText?: string;
+    confirmVariant?: "default" | "destructive";
+    showBackdrop?: boolean;
+    zIndex?: number;
 };
-declare const useDialog: () => {
-    show: (dialogConfig: DialogConfig) => void;
+type UseDialogResult = {
+    openDialog: (config: DialogConfig) => void;
     hide: () => void;
     isOpen: boolean;
-    DialogComponent: react_jsx_runtime.JSX.Element | null;
+    DialogComponent: null;
 };
+declare const useDialog: () => UseDialogResult;
 
-type ModalConfig = Omit<ModalProps, "open" | "onClose" | "children"> & {
-    component: ReactNode;
-    id: string;
-    onDismiss?: () => void;
+type ModalProps = {
+    open: boolean;
+    onClose: () => void;
+    content: ReactElement<BaseModalFrameProps>;
+    alignment?: ModalAlignment;
+    showBackdrop?: boolean;
+    size?: ModalSize;
+    zIndex?: number;
 };
-declare const ModalProvider: FC<{
+declare const Modal: FC<ModalProps>;
+
+type ModalFrameProps = {
+    onClose?: () => void;
     children: ReactNode;
-}>;
-declare const useModal: () => {
-    openModal: (component: ReactNode, options?: Omit<ModalConfig, "id" | "component">) => string;
-    closeModal: (id?: string) => void;
-    closeAllModals: () => void;
-    modalCount: number;
+    className?: string;
+    "data-testid"?: string;
 };
+declare const ModalFrame: FC<ModalFrameProps>;
 
-type ToastType = "default" | "success" | "error" | "warning" | "info";
-type ToastPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
-interface ToastData {
-    id: string;
-    message: ReactNode;
-    type: ToastType;
-    duration?: number;
-    closable?: boolean;
-    promise?: Promise<any>;
-    loadingText?: ReactNode;
-}
-interface ToastOptions {
-    duration?: number;
-    closable?: boolean;
+interface SchemaFormConfiguration<TSchema extends ObjectSchema<any> = ObjectSchema<any>, TData = any> {
+    api: ReactFormExtendedApi<TData, any, any, any, any, any, any, any, any, any, any, any>;
+    schema: TSchema;
+    mode: "edit" | "view" | "patch";
+    onPatch?: (fieldName: string, value: any) => Promise<void>;
+    formState: Record<string, any>;
 }
-interface PromiseToastOptions extends ToastOptions {
-    loadingText?: ReactNode;
+type UseSchemaFormOptions<TSchema extends ObjectSchema<any>, TData extends Infer<TSchema> = Infer<TSchema>> = {
+    schema: TSchema;
+    onSubmit: (data: TData) => void | Promise<void>;
+    /** Form mode - edit, view, or patch. Defaults to edit. When patch mode is used, onPatch is required. */
+    mode?: "edit" | "view" | "patch";
+    /** Callback for patching individual fields in patch mode */
+    onPatch?: (fieldName: string, value: any) => Promise<void>;
+    /** Initial values for the form fields */
+    initialValues?: Partial<TData>;
+};
+declare function useSchemaForm<TSchema extends ObjectSchema<any>, TData extends Infer<TSchema> = Infer<TSchema>>(options: UseSchemaFormOptions<TSchema, TData>): SchemaFormConfiguration<TSchema>;
+
+interface UseComputedMetadataOptions {
+    /** Debounce delay in milliseconds (default: 300ms) */
+    debounceMs?: number;
 }
-interface PromiseResult<T = any> {
-    success: boolean;
-    data?: T;
-    error?: any;
+interface UseComputedMetadataResult<TShape extends ObjectShape> {
+    /** Merged metadata for all properties (static + computed) */
+    metadata: Record<keyof TShape, SchemaMetadata<any>>;
+    /** Whether metadata is currently being computed */
+    isComputing: boolean;
+    /** Error that occurred during computation, if any */
+    error: Error | null;
 }
-interface PromiseToastConfig {
-    message: ReactNode;
-    type: ToastType;
-    duration?: number;
+/**
+ * Hook that provides debounced computed metadata for a form schema.
+ *
+ * This hook:
+ * 1. Watches for changes in form data
+ * 2. Debounces the computation to avoid excessive recalculation
+ * 3. Merges static metadata with computed metadata
+ * 4. Returns the final merged metadata for all properties
+ *
+ * @param schema The ObjectSchema with potential computed metadata
+ * @param formData Current form data (partial object)
+ * @param options Configuration options
+ * @returns Object with merged metadata, loading state, and error state
+ */
+declare function useComputedMetadata<TShape extends ObjectShape>(schema: ObjectSchema<TShape>, formData: Partial<ObjectOutput<TShape>>, options?: UseComputedMetadataOptions): UseComputedMetadataResult<TShape>;
+
+/**
+ * Pure function version of useLayout for testing and non-React contexts.
+ * This function has the same logic as useLayout but without React hooks.
+ */
+declare function getLayout<TShape extends ObjectShape>(schema: ObjectSchema<TShape>, layoutName?: string): Layout<TShape>;
+/**
+ * Hook to get a layout for a schema. If a layoutName is provided and exists in the schema,
+ * returns that layout. Otherwise, returns a default layout with all fields in a single group
+ * with size 12 (full width).
+ */
+declare function useLayout<TShape extends ObjectShape>(schema: ObjectSchema<TShape>, layoutName?: string): Layout<TShape>;
+
+interface HttpResponse<T = any> {
+    status: number;
+    data: T;
 }
-type PromiseToastCallback<T = any> = (result: PromiseResult<T>) => PromiseToastConfig;
-interface ToastContextType {
-    toasts: ToastData[];
-    addToast: (message: ReactNode, type: ToastType, options?: ToastOptions) => string;
-    addPromiseToast: <T>(promise: Promise<T>, callback: PromiseToastCallback<T>, options?: PromiseToastOptions) => string;
-    removeToast: (id: string) => void;
-    updateToast: (id: string, updates: Partial<ToastData>) => void;
+interface HttpRequestConfig {
+    headers?: Record<string, string>;
+    timeout?: number;
+    params?: Record<string, any>;
 }
-
-interface ToastProps {
-    toast: ToastData;
-    onClose: () => void;
+declare class HttpClient {
+    private baseUrl;
+    constructor({ baseUrl }: {
+        baseUrl?: string;
+    });
+    private request;
+    get<T>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    post<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    put<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    patch<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    delete<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
 }
-declare const Toast: FC<ToastProps>;
 
-interface ToastContainerProps {
-    className?: string;
+interface UseNubaseMutationOptions<TData = any, TVariables = any> {
+    /**
+     * Function that performs the mutation
+     * Should use the view's onSubmit function or similar
+     */
+    mutationFn: (variables: TVariables, context: any) => Promise<HttpResponse<TData>>;
+    /**
+     * Query keys to invalidate after successful mutation
+     * Can be a string pattern or array of exact keys
+     */
+    invalidateQueries?: (string | readonly unknown[])[];
+    /**
+     * Standard React Query mutation options
+     */
+    options?: Omit<UseMutationOptions<HttpResponse<TData>, Error, TVariables>, "mutationFn">;
 }
-declare const ToastContainer: FC<ToastContainerProps>;
+/**
+ * Custom hook that integrates React Query mutations with Nubase's context system
+ * Automatically handles query invalidation after successful mutations
+ *
+ * @example
+ * ```typescript
+ * const createTicketMutation = useNubaseMutation({
+ *   mutationFn: (data, context) => view.onSubmit({ data, context }),
+ *   invalidateQueries: [
+ *     ['resource', 'ticket', 'search'],
+ *     ['resource', 'ticket', 'view']
+ *   ],
+ *   options: {
+ *     onSuccess: (data) => {
+ *       showToast('Ticket created successfully', 'success');
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function useNubaseMutation<TData = any, TVariables = any>({ mutationFn, invalidateQueries, options, }: UseNubaseMutationOptions<TData, TVariables>): _tanstack_react_query.UseMutationResult<HttpResponse<TData>, Error, TVariables, unknown>;
+/**
+ * Hook specifically designed for resource creation operations
+ * Automatically invalidates related resource queries
+ */
+declare function useResourceCreateMutation<TData = any, TVariables = any>(resourceId: string, view: {
+    onSubmit: (args: {
+        data: TVariables;
+        context: any;
+    }) => Promise<HttpResponse<TData>>;
+}, options?: Omit<UseMutationOptions<HttpResponse<TData>, Error, TVariables>, "mutationFn">): _tanstack_react_query.UseMutationResult<HttpResponse<TData>, Error, TVariables, unknown>;
+/**
+ * Hook specifically designed for resource update/patch operations
+ * Automatically invalidates related resource queries
+ */
+declare function useResourceUpdateMutation<TData = any, TVariables = any>(resourceId: string, view: {
+    onPatch: (args: {
+        data: TVariables;
+        context: any;
+    }) => Promise<HttpResponse<TData>>;
+}, options?: Omit<UseMutationOptions<HttpResponse<TData>, Error, TVariables>, "mutationFn">): _tanstack_react_query.UseMutationResult<HttpResponse<TData>, Error, TVariables, unknown>;
+/**
+ * Hook specifically designed for resource deletion operations
+ * Automatically invalidates related resource queries
+ */
+declare function useResourceDeleteMutation<TData = any, TVariables = any>(_resourceId: string, view: {
+    onDelete: (args: {
+        data: TVariables;
+        context: any;
+    }) => Promise<HttpResponse<TData>>;
+}, options?: Omit<UseMutationOptions<HttpResponse<TData>, Error, TVariables>, "mutationFn">): _tanstack_react_query.UseMutationResult<HttpResponse<TData>, Error, TVariables, unknown>;
+/**
+ * Hook for invalidating specific resource queries manually
+ * Useful for custom invalidation scenarios
+ */
+declare function useResourceInvalidation(): {
+    /**
+     * Invalidate all queries for a specific resource
+     */
+    invalidateResource: (resourceId: string) => Promise<void>;
+    /**
+     * Invalidate search queries for a specific resource
+     */
+    invalidateResourceSearch: (resourceId: string) => Promise<void>;
+    /**
+     * Invalidate view queries for a specific resource
+     */
+    invalidateResourceView: (resourceId: string, params?: Record<string, any>) => Promise<void>;
+    /**
+     * Invalidate all queries matching a pattern
+     */
+    invalidateByPattern: (pattern: string) => Promise<void>;
+};
 
-declare const useToast: () => ToastContextType;
-interface ToastProviderProps {
-    children: ReactNode;
+interface UseNubaseQueryOptions<TData = any> {
+    /**
+     * Unique query key for this data fetching operation
+     * Should include relevant parameters that affect the data
+     */
+    queryKey: readonly unknown[];
+    /**
+     * Function that returns a promise with the data
+     * Should use the view's onLoad function or similar
+     */
+    queryFn: (context: any) => Promise<HttpResponse<TData>>;
+    /**
+     * Parameters that will be passed to the context
+     */
+    params?: Record<string, any>;
+    /**
+     * Standard React Query options
+     */
+    options?: Omit<UseQueryOptions<HttpResponse<TData>>, "queryKey" | "queryFn">;
 }
-declare const ToastProvider: ({ children }: ToastProviderProps) => react_jsx_runtime.JSX.Element;
-
-declare const showToast: (message: ReactNode, type?: ToastType, options?: ToastOptions) => string;
-declare const showPromiseToast: <T>(promise: Promise<T>, callback: PromiseToastCallback<T>, options?: PromiseToastOptions) => string;
+/**
+ * Custom hook that integrates React Query with Nubase's context and view system
+ *
+ * @example
+ * ```typescript
+ * const { data, isLoading, error } = useNubaseQuery({
+ *   queryKey: ['tickets', 'search', params],
+ *   queryFn: (context) => view.onLoad({ context }),
+ *   params: searchParams,
+ *   options: {
+ *     enabled: !!searchParams,
+ *   }
+ * });
+ * ```
+ */
+declare function useNubaseQuery<TData = any>({ queryKey, queryFn, params, options, }: UseNubaseQueryOptions<TData>): _tanstack_react_query.UseQueryResult<HttpResponse<TData>, Error>;
+/**
+ * Hook specifically designed for resource search views
+ * Automatically generates query keys and integrates with the view pattern
+ */
+declare function useResourceSearchQuery<TData = any>(resourceId: string, view: {
+    onLoad: (args: {
+        context: any;
+    }) => Promise<HttpResponse<TData>>;
+}, params?: Record<string, any>, options?: Omit<UseQueryOptions<HttpResponse<TData>>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<HttpResponse<TData>, Error>;
+/**
+ * Hook specifically designed for resource view operations
+ * Automatically generates query keys and integrates with the view pattern
+ */
+declare function useResourceViewQuery<TData = any>(resourceId: string, view: {
+    onLoad: (args: {
+        context: any;
+    }) => Promise<HttpResponse<TData>>;
+}, params?: Record<string, any>, options?: Omit<UseQueryOptions<HttpResponse<TData>>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<HttpResponse<TData>, Error>;
 
-interface ThemeToggleProps {
+interface SchemaFormBodyProps {
+    form: SchemaFormConfiguration<any>;
     className?: string;
-    defaultTheme: "light" | "dark";
-}
-declare const ThemeToggle: ({ className }: ThemeToggleProps) => react_jsx_runtime.JSX.Element;
-
-interface TreeNavigatorItem {
-    id: string;
-    icon: React.ReactNode;
-    title: string;
-    subtitle?: string;
-    onNavigate?: () => void;
-    href?: string;
-    onFocus?: () => void;
-    children?: TreeNavigatorItem[];
-}
-interface FlatItem extends TreeNavigatorItem {
-    level: number;
-    parentId?: string;
-    isExpanded?: boolean;
-    hasChildren: boolean;
-}
-interface TreeNavigatorItemComponentProps {
-    item: FlatItem;
-    index: number;
-    isSelected: boolean;
-    onToggleExpanded: (itemId: string) => void;
-    itemRef: (el: HTMLButtonElement | null) => void;
-}
-declare const TreeNavigatorItemComponent: ({ item, index, isSelected, onToggleExpanded, itemRef, }: TreeNavigatorItemComponentProps) => react_jsx_runtime.JSX.Element;
-
-interface MainNavProps extends React.HTMLAttributes<HTMLDivElement> {
-    items: TreeNavigatorItem[];
-    searchPlaceholder?: string;
-}
-declare const MainNav: React$1.ForwardRefExoticComponent<MainNavProps & React$1.RefAttributes<HTMLDivElement>>;
-
-interface NavItem {
-    id: string;
-    label: string;
-    children?: NavItem[];
-    href?: string;
-    onClick?: () => void;
-    disabled?: boolean;
-    badge?: string | number;
-}
-
-interface NavItemsProps {
-    items: NavItem[];
-    level?: number;
-    expandedItems: string[];
-    activeItemId?: string;
-    onToggle: (id: string) => void;
-    onItemClick?: (item: NavItem) => void;
+    layoutName?: string;
+    computedMetadata?: {
+        debounceMs?: number;
+    };
 }
-declare const NavItems: FC<NavItemsProps>;
+declare const SchemaFormBody: React__default.FC<SchemaFormBodyProps>;
 
-declare const flattenNavItems: (items: NavItem[], level?: number) => (NavItem & {
-    level: number;
-})[];
-declare const filterNavItems: (items: NavItem[], query: string) => NavItem[];
+type ModalFrameSchemaFormProps<TSchema extends ObjectSchema<any>> = {
+    onClose?: () => void;
+    title?: ReactNode;
+    form: SchemaFormConfiguration<TSchema>;
+    schemaFormProps?: Omit<SchemaFormBodyProps, "form">;
+    submitText?: string;
+    renderCustomFooter?: (form: SchemaFormConfiguration<TSchema>) => ReactNode;
+    className?: string;
+};
+declare const ModalFrameSchemaForm: <TSchema extends ObjectSchema<any>>({ onClose, title, form, schemaFormProps, submitText, renderCustomFooter, className, }: ModalFrameSchemaFormProps<TSchema>) => ReturnType<FC>;
 
-interface TreeNavigatorProps {
-    items: TreeNavigatorItem[];
-    searchInputRef?: RefObject<HTMLInputElement>;
-}
-declare const TreeNavigator: ({ items, searchInputRef, }: TreeNavigatorProps) => react_jsx_runtime.JSX.Element;
-declare const ListNavigator: ({ items, searchInputRef, }: TreeNavigatorProps) => react_jsx_runtime.JSX.Element;
-type ListNavigatorItem = TreeNavigatorItem;
-type ListNavigatorProps = TreeNavigatorProps;
+type ModalFrameStructuredProps = {
+    onClose?: () => void;
+    header?: ReactNode;
+    body?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+};
+declare const ModalFrameStructured: FC<ModalFrameStructuredProps>;
 
-type SearchableTreeNavigatorProps = {
-    items: TreeNavigatorItem[];
-    placeHolder: string;
-    height?: "full" | number | string;
+declare const ModalProvider: FC<{
+    children: ReactNode;
+}>;
+type UseModalResult = {
+    openModal: (config: ModalConfig) => string;
+    closeModal: (id?: string) => void;
+    closeAllModals: () => void;
+    modalCount: number;
 };
-declare const SearchableTreeNavigator: React$1.ForwardRefExoticComponent<SearchableTreeNavigatorProps & React$1.RefAttributes<HTMLInputElement>>;
-declare const SearchableListNavigator: React$1.ForwardRefExoticComponent<SearchableTreeNavigatorProps & React$1.RefAttributes<HTMLInputElement>>;
-type SearchableListNavigatorProps = SearchableTreeNavigatorProps;
+declare const useModal: () => UseModalResult;
 
-interface HttpResponse<T = any> {
-    status: number;
-    data: T;
-}
-interface HttpRequestConfig {
-    headers?: Record<string, string>;
-    timeout?: number;
+/**
+ * Defines the layout of actions for views.
+ * An action layout is an array of action IDs and separators.
+ * This allows views to specify which actions to display and in what order.
+ */
+type ActionLayout<TActionIds extends string = string> = (TActionIds | "separator")[];
+
+/**
+ * Represents a single breadcrumb item in the navigation trail.
+ */
+type BreadcrumbItem$1 = string | {
+    label: string;
+    /**
+     * Optional navigation path. Can be:
+     * - A string path (e.g., "/r/ticket/search")
+     * - A ResourceLink for type-safe resource navigation
+     */
+    to?: string | ResourceLink;
     params?: Record<string, any>;
-}
-declare class HttpClient {
-    private baseUrl;
-    constructor({ baseUrl }: {
-        baseUrl?: string;
-    });
-    private request;
-    get<T>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-    post<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-    put<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-    patch<T>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-    delete<T>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-}
+    search?: Record<string, any>;
+};
+/**
+ * Breadcrumb definition that can be static or dynamically generated based on context.
+ * Dynamic breadcrumbs have access to route parameters, loaded data, and other context.
+ */
+type BreadcrumbDefinition<TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TData = any> = BreadcrumbItem$1[] | ((context: {
+    context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    data?: TData;
+}) => BreadcrumbItem$1[]);
 
 type ViewType = "object";
-type ViewBase = {
+type ViewBase<TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TData = any> = {
     title: string;
     id: string;
+    /**
+     * Optional breadcrumb navigation trail for this view.
+     */
+    breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema, TData>;
 };
-type CreateView<TSchema extends ObjectSchema<any> = ObjectSchema<any>, THttpClient = any> = ViewBase & {
-    type: "create";
-    schema: TSchema;
-    onSubmit: ({ data, http, }: {
+type ResourceCreateView<TSchema extends ObjectSchema<any> = ObjectSchema<any>, TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string> = ViewBase<TApiEndpoints, TParamsSchema> & {
+    type: "resource-create";
+    /**
+     * Schema for the form data to be posted when creating a resource.
+     */
+    schemaPost: TSchema;
+    /**
+     * Optional schema for URL parameters this view expects.
+     */
+    schemaParams?: TParamsSchema;
+    /**
+     * Optional actions to display for this view (e.g., save, cancel, reset).
+     */
+    actions?: ActionLayout<TActionIds>;
+    /**
+     * Creates a new resource.
+     */
+    onSubmit: ({ data, context, }: {
         data: Infer<TSchema>;
-        http: THttpClient;
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
     }) => Promise<HttpResponse<any>>;
 };
-type ViewView<TSchema extends ObjectSchema<any> = ObjectSchema<any>> = ViewBase & {
-    type: "view";
-    schema: TSchema;
+type ResourceViewView<TSchema extends ObjectSchema<any> = ObjectSchema<any>, TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string> = ViewBase<TApiEndpoints, TParamsSchema, Infer<TSchema>> & {
+    type: "resource-view";
+    /**
+     * Schema for the resource data retrieved from the server.
+     */
+    schemaGet: TSchema;
+    /**
+     * Optional schema for URL parameters this view expects.
+     */
+    schemaParams?: TParamsSchema;
+    /**
+     * Optional actions to display for this view (e.g., edit, delete, duplicate).
+     */
+    actions?: ActionLayout<TActionIds>;
+    /**
+     * Loads the resource data.
+     */
+    onLoad: ({ context, }: {
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<Infer<TSchema>>>;
+    /**
+     * Patches a resource with partial data.
+     */
+    onPatch: ({ data, context, }: {
+        data: Partial<Infer<TSchema>>;
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<any>>;
 };
-type View<TSchema extends ObjectSchema<any> = ObjectSchema<any>, THttpClient = any> = CreateView<TSchema, THttpClient> | ViewView<TSchema>;
-
-type NubaseFrontendConfig<TApiEndpoints = any> = {
-    appName: string;
-    mainMenu: TreeNavigatorItem[];
+type ResourceSearchView<TSchema extends ArraySchema<any> = ArraySchema<any>, TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string> = ViewBase<TApiEndpoints, TParamsSchema> & {
+    type: "resource-search";
     /**
-     * Maps a view-id to a view configuration.
+     * Schema for the search results data retrieved from the server.
      */
-    views: Record<string, View>;
+    schemaGet: TSchema;
     /**
-     * If set, this will be used as the base URL for all HTTP requests.
-     * If not set, only full URLs will be used in HTTP requests.
+     * Optional schema for URL parameters this view expects.
      */
-    apiBaseUrl?: string;
+    schemaParams?: TParamsSchema;
     /**
-     * API endpoints definition for type-safe client generation.
-     * The framework will automatically create a typed API client from these endpoints.
-     * Supports nested structure like: { tickets: { createTicket: schema, ... }, users: { ... } }
+     * Optional actions to display above the table for bulk operations on selected items.
      */
-    apiEndpoints?: TApiEndpoints;
-    themeIds?: string[];
-    defaultThemeId?: "light" | "dark";
+    tableActions?: ActionLayout<TActionIds>;
+    /**
+     * Optional actions to display in the dropdown for each row.
+     */
+    rowActions?: ActionLayout<TActionIds>;
+    /**
+     * Loads the search results data.
+     */
+    onLoad: ({ context, }: {
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<Infer<TSchema>>>;
 };
+type View<TSchema extends ObjectSchema<any> | ArraySchema<any> = ObjectSchema<any>, TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string> = ResourceCreateView<TSchema extends ObjectSchema<any> ? TSchema : ObjectSchema<any>, TApiEndpoints, TParamsSchema, TActionIds> | ResourceViewView<TSchema extends ObjectSchema<any> ? TSchema : ObjectSchema<any>, TApiEndpoints, TParamsSchema, TActionIds> | ResourceSearchView<TSchema extends ArraySchema<any> ? TSchema : ArraySchema<any>, TApiEndpoints, TParamsSchema, TActionIds>;
 
-type NubaseAppProps = {
-    config: NubaseFrontendConfig;
+/**
+ * A resource descriptor defines the views available for a resource entity.
+ * Views are directly accessible without an intermediate operation wrapper.
+ * Can be extended with additional properties as needed.
+ */
+type ResourceDescriptor<TViews extends Record<string, View<any, any, any, any>> = Record<string, View<any, any, any, any>>, TActions extends Record<string, Action> = Record<string, Action>> = {
+    id: string;
+    views: TViews;
+    /**
+     * Available actions for this resource, defined as an object mapping action IDs to action definitions.
+     * This allows views to reference actions by ID in a type-safe manner.
+     */
+    actions?: TActions;
 };
-declare const NubaseApp: FC<NubaseAppProps>;
-
-declare const tableVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
-interface TableProps<TData> extends React__default.TableHTMLAttributes<HTMLTableElement> {
-    data: TData[];
-    columns: ColumnDef<TData>[];
-    loading?: boolean;
-    sorting?: SortingState;
-    onSortingChange?: OnChangeFn<SortingState>;
-    enableSorting?: boolean;
-    emptyMessage?: string;
-    loadingMessage?: string;
-    containerClassName?: string;
-}
-declare const Table: React__default.ForwardRefExoticComponent<TableProps<any> & React__default.RefAttributes<HTMLTableElement>>;
-
-declare const paginationVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
-interface PaginationProps extends React__default.HTMLAttributes<HTMLDivElement> {
-    currentPage: number;
-    totalPages: number;
-    pageSize: number;
-    totalItems: number;
-    onPageChange: (page: number) => void;
-    onPageSizeChange?: (pageSize: number) => void;
-    pageSizeOptions?: number[];
-    showPageSizeSelector?: boolean;
-    showInfo?: boolean;
-}
-declare const Pagination: React__default.ForwardRefExoticComponent<PaginationProps & React__default.RefAttributes<HTMLDivElement>>;
+/**
+ * Standard view names for resources
+ */
+type StandardViews = "create" | "view" | "edit";
 
-interface UseComputedMetadataOptions {
-    /** Debounce delay in milliseconds (default: 300ms) */
-    debounceMs?: number;
-}
-interface UseComputedMetadataResult<TShape extends ObjectShape> {
-    /** Merged metadata for all properties (static + computed) */
-    metadata: Record<keyof TShape, SchemaMetadata<any>>;
-    /** Whether metadata is currently being computed */
-    isComputing: boolean;
-    /** Error that occurred during computation, if any */
-    error: Error | null;
-}
 /**
- * Hook that provides debounced computed metadata for a form schema.
+ * A type-safe link to a resource view.
  *
- * This hook:
- * 1. Watches for changes in form data
- * 2. Debounces the computation to avoid excessive recalculation
- * 3. Merges static metadata with computed metadata
- * 4. Returns the final merged metadata for all properties
+ * ResourceLink objects are resolved at runtime to include the current workspace.
+ * This enables type-safe navigation to resource views without hardcoding paths.
  *
- * @param schema The ObjectSchema with potential computed metadata
- * @param formData Current form data (partial object)
- * @param options Configuration options
- * @returns Object with merged metadata, loading state, and error state
+ * @example
+ * ```typescript
+ * // Create a link to the ticket search view
+ * const link = resourceLink(ticketResource, "search");
+ *
+ * // Use in menu configuration
+ * mainMenu: [
+ *   { id: "tickets", label: "Tickets", href: resourceLink(ticketResource, "search") }
+ * ]
+ * ```
  */
-declare function useComputedMetadata<TShape extends ObjectShape>(schema: ObjectSchema<TShape>, formData: Partial<ObjectOutput<TShape>>, options?: UseComputedMetadataOptions): UseComputedMetadataResult<TShape>;
-
+interface ResourceLink<TResourceId extends string = string, TViewName extends string = string> {
+    /** Discriminator for identifying ResourceLink objects */
+    readonly __type: "resourceLink";
+    /** The resource ID (e.g., "ticket") */
+    readonly resourceId: TResourceId;
+    /** The view name on the resource (e.g., "search", "create", "view") */
+    readonly viewName: TViewName;
+    /** Optional search params to include in the URL */
+    readonly search?: Record<string, unknown>;
+}
 /**
- * Pure function version of useLayout for testing and non-React contexts.
- * This function has the same logic as useLayout but without React hooks.
+ * Creates a type-safe link to a resource view.
+ *
+ * The link is resolved at runtime to include the current workspace prefix.
+ * This ensures links work correctly across different workspaces without
+ * hardcoding the workspace slug.
+ *
+ * @param resource - The resource descriptor containing the view
+ * @param viewName - The name of the view to link to (type-safe based on resource's views)
+ * @param search - Optional search parameters to include in the URL
+ * @returns A ResourceLink object that can be used as a MenuItem href
+ *
+ * @example
+ * ```typescript
+ * const ticketResource = createResource("ticket")
+ *   .withViews({
+ *     search: { type: "resource-search", ... },
+ *     create: { type: "resource-create", ... },
+ *     view: { type: "resource-view", ... }
+ *   });
+ *
+ * // Type-safe: only "search", "create", or "view" are valid
+ * resourceLink(ticketResource, "search")
+ *
+ * // With search params
+ * resourceLink(ticketResource, "view", { id: 123 })
+ *
+ * // TypeScript error: "invalid" is not a valid view name
+ * resourceLink(ticketResource, "invalid") // ❌ Type error
+ * ```
  */
-declare function getLayout<TShape extends ObjectShape>(schema: ObjectSchema<TShape>, layoutName?: string): Layout<TShape>;
+declare function resourceLink<TResource extends ResourceDescriptor<any, any>, TViewName extends keyof TResource["views"] & string>(resource: TResource, viewName: TViewName, search?: Record<string, unknown>): ResourceLink<string, TViewName>;
 /**
- * Hook to get a layout for a schema. If a layoutName is provided and exists in the schema,
- * returns that layout. Otherwise, returns a default layout with all fields in a single group
- * with size 12 (full width).
+ * Type guard to check if a value is a ResourceLink.
  */
-declare function useLayout<TShape extends ObjectShape>(schema: ObjectSchema<TShape>, layoutName?: string): Layout<TShape>;
-
+declare function isResourceLink(value: unknown): value is ResourceLink;
 /**
- * Utility function for merging Tailwind CSS classes with conditional logic.
- *
- * This function combines clsx for conditional class handling with tailwind-merge
- * to resolve Tailwind class conflicts. It's commonly used throughout the component
- * library to merge default component styles with user-provided className props.
+ * Resolves a ResourceLink to a URL path.
  *
- * @param inputs - Array of class values (strings, objects, arrays, etc.)
- * @returns A string of merged and deduplicated Tailwind classes
+ * @param link - The ResourceLink to resolve
+ * @param workspaceSlug - The current workspace slug (optional)
+ * @returns The resolved URL path
  *
  * @example
- * cn("px-4 py-2", "bg-blue-500", { "text-white": isActive })
- * // Returns: "px-4 py-2 bg-blue-500 text-white" (if isActive is true)
+ * ```typescript
+ * const link = resourceLink(ticketResource, "search");
+ * resolveResourceLink(link, "tavern")
+ * // Returns: "/tavern/r/ticket/search"
  *
- * @example
- * cn("bg-red-500", "bg-blue-500")
- * // Returns: "bg-blue-500" (tailwind-merge resolves the conflict)
+ * resolveResourceLink(link)
+ * // Returns: "/r/ticket/search"
+ * ```
  */
-declare function cn(...inputs: ClassValue[]): string;
-
+declare function resolveResourceLink(link: ResourceLink, workspaceSlug?: string): string;
+/**
+ * Resolves a ResourceLink's search params to a query string object.
+ */
+declare function getResourceLinkSearch(link: ResourceLink): Record<string, unknown> | undefined;
+
+/**
+ * Standard icon type used throughout Nubase.
+ * Icons are passed as component types (not instantiated) for consistency and flexibility.
+ */
+type IconComponent = React__default.ComponentType<{
+    size?: number;
+    className?: string;
+}>;
+/**
+ * Unified menu item type that works for main navigation, command palettes,
+ * global actions, and any other menu-like UI.
+ *
+ * This replaces the previous TreeNavigatorItem and Action types with a single,
+ * consistent interface.
+ *
+ * @example
+ * // Simple link navigation
+ * { id: "home", label: "Home", icon: Home, href: "/" }
+ *
+ * @example
+ * // Command-based action (derives label/icon from command)
+ * { id: "theme", command: commands.workbenchSetTheme }
+ *
+ * @example
+ * // Command with overridden label
+ * { id: "create", label: "New Ticket", command: commands.workbenchOpenResourceOperation, commandArgs: { operation: "create" } }
+ *
+ * @example
+ * // Hierarchical menu
+ * {
+ *   id: "settings",
+ *   label: "Settings",
+ *   icon: Settings,
+ *   children: [
+ *     { id: "theme", command: commands.workbenchSetTheme },
+ *     { id: "profile", label: "Profile", href: "/settings/profile" },
+ *   ]
+ * }
+ *
+ * @example
+ * // Direct handler (for simple cases)
+ * { id: "logout", label: "Sign Out", icon: LogOut, onExecute: () => signOut() }
+ */
+interface MenuItem {
+    id: string;
+    /**
+     * Display label for the menu item.
+     * Optional if `command` is provided - will be derived from command's `name`.
+     * Required for `href` or `onExecute` items.
+     */
+    label?: string;
+    /**
+     * Optional subtitle/description shown below the label.
+     */
+    subtitle?: string;
+    /**
+     * Icon component (not instantiated).
+     * Optional if `command` is provided - will be derived from command's `icon`.
+     */
+    icon?: IconComponent;
+    /**
+     * Whether the menu item is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Visual variant for the menu item.
+     */
+    variant?: "default" | "destructive";
+    /**
+     * URL to navigate to. Uses client-side routing.
+     * Can be a string path or a ResourceLink for type-safe resource navigation.
+     * Mutually exclusive with `command` and `onExecute`.
+     *
+     * @example
+     * // String path
+     * { href: "/settings" }
+     *
+     * // Type-safe resource link
+     * { href: resourceLink(ticketResource, "search") }
+     */
+    href?: string | ResourceLink;
+    /**
+     * Command to execute when the menu item is activated.
+     * Can be a command definition object or a command ID string.
+     * When provided, `label` and `icon` can be derived from the command.
+     * Mutually exclusive with `href` and `onExecute`.
+     */
+    command?: TypedCommandDefinition<any> | string;
+    /**
+     * Arguments to pass to the command.
+     * Only used when `command` is provided.
+     */
+    commandArgs?: Record<string, unknown>;
+    /**
+     * Direct handler function for simple actions.
+     * Mutually exclusive with `href` and `command`.
+     */
+    onExecute?: () => void | Promise<void>;
+    /**
+     * Callback when this item receives focus (via keyboard navigation).
+     * Useful for preview effects (e.g., theme preview on hover/focus).
+     */
+    onFocus?: () => void;
+    /**
+     * Child menu items for hierarchical menus.
+     * When present, the item acts as a parent/folder.
+     */
+    children?: MenuItem[];
+}
+/**
+ * Menu item or separator literal for creating grouped menus.
+ */
+type MenuItemOrSeparator = MenuItem | "separator";
+
+type SeriesChartVariant = "line" | "bar" | "area";
+type ProportionalChartVariant = "pie" | "donut";
+interface WidgetLayoutConfig {
+    /** Column position (0-based) */
+    x: number;
+    /** Row position (0-based) */
+    y: number;
+    /** Width in grid columns */
+    w: number;
+    /** Height in grid rows */
+    h: number;
+    /** Minimum width in grid columns */
+    minW?: number;
+    /** Minimum height in grid rows */
+    minH?: number;
+    /** Maximum width in grid columns */
+    maxW?: number;
+    /** Maximum height in grid rows */
+    maxH?: number;
+    /** Whether the widget cannot be moved or resized */
+    static?: boolean;
+}
+/**
+ * Extract endpoint keys that return SeriesData.
+ * Matches endpoints created with createSeriesWidgetEndpoint.
+ */
+type SeriesEndpointKeys<TApiEndpoints> = {
+    [K in keyof TApiEndpoints]: TApiEndpoints[K] extends SeriesWidgetRequestSchema ? K : never;
+}[keyof TApiEndpoints];
+/**
+ * Extract endpoint keys that return ProportionalData.
+ * Matches endpoints created with createProportionalWidgetEndpoint.
+ */
+type ProportionalEndpointKeys<TApiEndpoints> = {
+    [K in keyof TApiEndpoints]: TApiEndpoints[K] extends ProportionalWidgetRequestSchema ? K : never;
+}[keyof TApiEndpoints];
+/**
+ * Extract endpoint keys that return KpiData.
+ * Matches endpoints created with createKpiWidgetEndpoint.
+ */
+type KpiEndpointKeys<TApiEndpoints> = {
+    [K in keyof TApiEndpoints]: TApiEndpoints[K] extends KpiWidgetRequestSchema ? K : never;
+}[keyof TApiEndpoints];
+/**
+ * Extract endpoint keys that return TableData.
+ * Matches endpoints created with createTableWidgetEndpoint.
+ */
+type TableEndpointKeys<TApiEndpoints> = {
+    [K in keyof TApiEndpoints]: TApiEndpoints[K] extends TableWidgetRequestSchema ? K : never;
+}[keyof TApiEndpoints];
+interface BaseWidgetDescriptor {
+    /** Unique identifier for this widget */
+    id: string;
+    /** Display title for the widget header */
+    title: string;
+    /** Optional icon for the widget header */
+    icon?: IconComponent;
+    /** Default grid layout position and size */
+    defaultLayout?: WidgetLayoutConfig;
+    /** Optional refresh interval in milliseconds */
+    refreshInterval?: number;
+}
+interface SeriesWidgetDescriptor<TApiEndpoints> extends BaseWidgetDescriptor {
+    type: "series";
+    /** The chart variant to render */
+    variant: SeriesChartVariant;
+    /**
+     * The API endpoint key that provides data for this widget.
+     * TypeScript will only allow endpoints that return SeriesData.
+     */
+    endpoint: SeriesEndpointKeys<TApiEndpoints>;
+}
+interface ProportionalWidgetDescriptor<TApiEndpoints> extends BaseWidgetDescriptor {
+    type: "proportional";
+    /** The chart variant to render */
+    variant: ProportionalChartVariant;
+    /**
+     * The API endpoint key that provides data for this widget.
+     * TypeScript will only allow endpoints that return ProportionalData.
+     */
+    endpoint: ProportionalEndpointKeys<TApiEndpoints>;
+}
+interface KpiWidgetDescriptor<TApiEndpoints> extends BaseWidgetDescriptor {
+    type: "kpi";
+    /**
+     * The API endpoint key that provides data for this widget.
+     * TypeScript will only allow endpoints that return KpiData.
+     */
+    endpoint: KpiEndpointKeys<TApiEndpoints>;
+}
+interface TableWidgetDescriptor<TApiEndpoints> extends BaseWidgetDescriptor {
+    type: "table";
+    /**
+     * The API endpoint key that provides data for this widget.
+     * TypeScript will only allow endpoints that return TableData.
+     */
+    endpoint: TableEndpointKeys<TApiEndpoints>;
+    /** Maximum rows to display */
+    maxRows?: number;
+}
+/**
+ * Union of all widget descriptor types.
+ * Each widget type enforces that its endpoint returns the correct data shape.
+ */
+type WidgetDescriptor<TApiEndpoints> = SeriesWidgetDescriptor<TApiEndpoints> | ProportionalWidgetDescriptor<TApiEndpoints> | KpiWidgetDescriptor<TApiEndpoints> | TableWidgetDescriptor<TApiEndpoints>;
+interface DashboardGridConfig {
+    /** Number of columns in the grid */
+    cols?: number;
+    /** Height of a single row in pixels */
+    rowHeight?: number;
+    /** Margin between items [horizontal, vertical] in pixels */
+    margin?: [number, number];
+    /** Container padding [horizontal, vertical] in pixels */
+    containerPadding?: [number, number];
+}
+interface DashboardDescriptor<TApiEndpoints> {
+    /** Unique identifier for this dashboard */
+    id: string;
+    /** Display title for the dashboard */
+    title: string;
+    /** Optional icon for the dashboard */
+    icon?: IconComponent;
+    /** Widget configurations for this dashboard */
+    widgets: WidgetDescriptor<TApiEndpoints>[];
+    /** Optional grid configuration */
+    gridConfig?: DashboardGridConfig;
+}
+
+/**
+ * Global actions configuration type that supports separators for grouping.
+ * Uses the standardized ActionOrSeparator which supports both command and handler actions.
+ */
+type GlobalActionsConfig = ActionOrSeparator[];
+
+type NubaseFrontendConfig<TApiEndpoints = any> = {
+    appName: string;
+    /**
+     * Main navigation menu items.
+     * Supports hierarchical structure with commands, links, or direct handlers.
+     */
+    mainMenu: MenuItem[];
+    /**
+     * Maps a resource-id to a resource descriptor configuration.
+     * Resources define all available operations (create, view, edit, etc.) for entities.
+     */
+    resources: Record<string, ResourceDescriptor<any>>;
+    /**
+     * Global actions that appear in the top bar.
+     * Actions execute commands with optional parameters and support separators for grouping.
+     */
+    globalActions?: GlobalActionsConfig;
+    /**
+     * If set, this will be used as the base URL for all HTTP requests.
+     * If not set, only full URLs will be used in HTTP requests.
+     */
+    apiBaseUrl?: string;
+    /**
+     * API endpoints definition for type-safe client generation.
+     * The framework will automatically create a typed API client from these endpoints.
+     * Supports nested structure like: { tickets: { createTicket: schema, ... }, users: { ... } }
+     */
+    apiEndpoints?: TApiEndpoints;
+    /**
+     * Custom keybindings for the application.
+     * If not provided, default keybindings will be used.
+     * Use defaultKeybindings.extend() to extend defaults with custom bindings.
+     */
+    keybindings?: Keybinding[];
+    themeIds?: string[];
+    defaultThemeId?: "light" | "dark";
+    /**
+     * Authentication controller for managing user authentication.
+     * When provided, enables authentication features like auto-redirect to signin.
+     */
+    authentication?: AuthenticationController;
+    /**
+     * Routes that don't require authentication.
+     * Users can access these routes without being logged in.
+     * Default: ['/signin']
+     */
+    publicRoutes?: string[];
+    /**
+     * Dashboard configurations for the application.
+     * Each dashboard contains widgets that render data from API endpoints.
+     *
+     * @example
+     * ```typescript
+     * dashboards: {
+     *   [analyticsDashboard.id]: analyticsDashboard,
+     * }
+     * ```
+     */
+    dashboards?: Record<string, DashboardDescriptor<TApiEndpoints>>;
+};
+
 type TypedMethodOptions<T extends RequestSchema> = {
     params?: InferRequestParams<T>;
     data?: InferRequestBody<T>;
     config?: HttpRequestConfig;
 };
-type MethodSignature<T extends RequestSchema> = T["method"] extends "GET" ? (options?: Omit<TypedMethodOptions<T>, "data">) => Promise<HttpResponse<InferResponseBody<T>>> : (options?: TypedMethodOptions<T>) => Promise<HttpResponse<InferResponseBody<T>>>;
+type ErrorListener = (error: Error) => void;
+type MethodSignature<T extends RequestSchema> = T["method"] extends "GET" ? (options?: Omit<TypedMethodOptions<T>, "data">) => Promise<HttpResponse<InferResponseBody<T>>> : T["requestBody"] extends ObjectSchema ? (options?: TypedMethodOptions<T>) => Promise<HttpResponse<InferResponseBody<T>>> : (options?: Omit<TypedMethodOptions<T>, "data">) => Promise<HttpResponse<InferResponseBody<T>>>;
 type TypedApiMethods<T> = {
     [K in keyof T]: T[K] extends RequestSchema ? MethodSignature<T[K]> : never;
 };
 declare class TypedApiClient<T> {
     private httpClient;
     private endpoints;
-    constructor(httpClient: HttpClient, endpoints: T);
+    private errorListener?;
+    constructor(httpClient: HttpClient, endpoints: T, errorListener?: ErrorListener);
     private createFlatApiClient;
     private executeRequest;
     private isRequestSchema;
-    private capitalize;
 }
-declare function createTypedApiClient<T>(httpClient: HttpClient, endpoints: T): TypedApiClient<T> & TypedApiMethods<T>;
+declare function createTypedApiClient<T>(httpClient: HttpClient, endpoints: T, errorListener?: ErrorListener): TypedApiClient<T> & TypedApiMethods<T>;
 
 /**
  * Type helper to extract the typed API client type from an endpoints definition.
@@ -514,4 +1061,2455 @@ declare function createTypedApiClient<T>(httpClient: HttpClient, endpoints: T):
  */
 type TypedApiClientFromEndpoints<T> = ReturnType<typeof createTypedApiClient<T>>;
 
-export { Button, type ButtonProps, type CreateView, Dialog, type DialogProps, Dock, type DockProps, type FieldApi, type FlatItem, FormControl, type FormControlProps, FormFieldRenderer, type FormFieldRendererProps, HttpClient, type HttpRequestConfig, type HttpResponse, Label, type LabelProps, ListNavigator, type ListNavigatorItem, type ListNavigatorProps, MainNav, type MainNavProps, Modal, type ModalAlignment, type ModalProps, ModalProvider, type NavItem, NavItems, NubaseApp, type NubaseAppProps, type NubaseFrontendConfig, Pagination, type PaginationProps, type PromiseResult, type PromiseToastCallback, type PromiseToastConfig, type PromiseToastOptions, SchemaForm, SchemaFormLayout, type SchemaFormLayoutProps, type SchemaFormProps, type SchemaFormRef, SearchTextInput, type SearchTextInputProps, SearchableListNavigator, type SearchableListNavigatorProps, SearchableTreeNavigator, type SearchableTreeNavigatorProps, Select, type SelectOption, type SelectProps, Table, type TableProps, TextInput, type TextInputProps, ThemeToggle, type ThemeToggleProps, Toast, ToastContainer, type ToastData, type ToastOptions, type ToastPosition, ToastProvider, type ToastType, TreeNavigator, type TreeNavigatorItem, TreeNavigatorItemComponent, type TreeNavigatorProps, TypedApiClient, type TypedApiClientFromEndpoints, type View, type ViewBase, type ViewType, type ViewView, cn, createTypedApiClient, filterNavItems, flattenNavItems, getLayout, paginationVariants, showPromiseToast, showToast, tableVariants, useComputedMetadata, useDialog, useLayout, useModal, useToast };
+interface NavigationHistoryEntry {
+    id: string;
+    path: string;
+    pathname: string;
+    search: string;
+    searchParams: Record<string, any>;
+    hash: string;
+    timestamp: number;
+    title: string;
+}
+declare class NavigationHistoryTracker {
+    private history;
+    private maxHistorySize;
+    private unsubscribe;
+    private router;
+    private lastEntryId;
+    private historyIdCounter;
+    constructor(router: AnyRouter);
+    private formatTitle;
+    private parseSearchParams;
+    private addCurrentLocation;
+    private addEntry;
+    private startTracking;
+    getHistory(): NavigationHistoryEntry[];
+    clearHistory(): void;
+    dispose(): void;
+    navigateToEntry(entry: NavigationHistoryEntry): void;
+    formatTimeAgo(timestamp: number): string;
+}
+
+interface NubaseTheme {
+    id: string;
+    name: string;
+    type: "light" | "dark";
+    colors: NubaseThemeColors;
+}
+type NubaseThemeColors = {
+    background: string;
+    foreground: string;
+    card: string;
+    cardForeground: string;
+    popover: string;
+    popoverForeground: string;
+    primary: string;
+    primaryForeground: string;
+    secondary: string;
+    secondaryForeground: string;
+    muted: string;
+    mutedForeground: string;
+    accent: string;
+    accentForeground: string;
+    destructive: string;
+    destructiveForeground: string;
+    border: string;
+    input: string;
+    ring: string;
+    chart1: string;
+    chart2: string;
+    chart3: string;
+    chart4: string;
+    chart5: string;
+    sidebar: string;
+    sidebarForeground: string;
+    sidebarPrimary: string;
+    sidebarPrimaryForeground: string;
+    sidebarAccent: string;
+    sidebarAccentForeground: string;
+    sidebarBorder: string;
+    sidebarRing: string;
+};
+
+interface NubaseContextData<TApiEndpoints = any, TParamsSchema extends ObjectSchema<any> | undefined = undefined> {
+    config: NubaseFrontendConfig<TApiEndpoints>;
+    commands: CommandRegistry;
+    resourceActions: ResourceActionsExecutor;
+    keybindings: Keybinding[];
+    /**
+     * Typed HTTP client instance created from the configured API endpoints.
+     * This is the client that views should use for type-safe API calls.
+     */
+    http: TypedApiClientFromEndpoints<TApiEndpoints>;
+    modal: UseModalResult;
+    /**
+     * Dialog provider for confirmation dialogs and alerts.
+     */
+    dialog: UseDialogResult;
+    /**
+     * React Query client for cache management and query invalidation.
+     */
+    queryClient: QueryClient;
+    theming: {
+        themeIds: string[];
+        themeMap: Record<string, NubaseTheme>;
+        activeThemeId: string;
+        setActiveThemeId: (themeId: string) => void;
+    };
+    router: AnyRouter;
+    /**
+     * Navigation history tracker for tracking and accessing route history.
+     */
+    navigationHistory: NavigationHistoryTracker;
+    /**
+     * URL parameters extracted and validated against the view's schemaParams.
+     * Only present when the view defines a schemaParams.
+     */
+    params: TParamsSchema extends ObjectSchema<any> ? Infer<TParamsSchema> : undefined;
+    /**
+     * Authentication controller for managing user authentication.
+     * Null if no authentication is configured.
+     */
+    authentication: AuthenticationController | null;
+    /**
+     * Current workspace slug extracted from the URL path (e.g., "tavern" from /tavern/r/ticket/create).
+     * Used for path-based multi-workspace.
+     */
+    workspace: string | null;
+}
+
+/**
+ * Type-safe command definition that uses Nubase schemas for argument validation.
+ *
+ * @template TArgsSchema - The schema type for command arguments, or undefined if no args
+ */
+interface TypedCommandDefinition<TArgsSchema extends BaseSchema<any> | undefined = undefined> {
+    id: string;
+    name: string;
+    /**
+     * Icon component (not instantiated) for this command.
+     * Used in command palettes, menus, and anywhere the command is displayed.
+     */
+    icon?: IconComponent;
+    /**
+     * Optional schema for validating command arguments.
+     * If provided, arguments will be validated at runtime.
+     */
+    argsSchema?: TArgsSchema;
+    /**
+     * Command execution function with type-safe arguments.
+     * Args are typed based on the provided schema.
+     */
+    execute: (context: NubaseContextData, args: TArgsSchema extends BaseSchema<any> ? Infer<TArgsSchema> : undefined) => void | Promise<void>;
+}
+/**
+ * Modern keybinding interface using typed actions.
+ * Supports both handler and command actions with full type safety.
+ */
+interface ActionKeybinding {
+    key: string | string[];
+    action: Action;
+}
+/**
+ * Union type supporting both legacy command and modern action keybindings.
+ * Provides backward compatibility while enabling type-safe actions.
+ */
+type Keybinding = {
+    key: string | string[];
+    command: string;
+    commandArgs?: Record<string, unknown>;
+} | ActionKeybinding;
+interface CommandRegistry {
+    register: (command: TypedCommandDefinition<any>) => void;
+    execute: (commandId: string, args?: unknown) => Promise<void>;
+    getCommand: (commandId: string) => TypedCommandDefinition<any> | undefined;
+    getAllCommands: () => TypedCommandDefinition<any>[];
+}
+
+/**
+ * Base action interface with common properties shared by all action types.
+ */
+interface BaseAction {
+    id: string;
+    label?: string;
+    icon?: React__default.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    disabled?: boolean;
+    variant?: "default" | "destructive";
+}
+/**
+ * Context provided to handler actions when executed from row-level components
+ */
+interface ActionExecutionContext {
+    rowData?: any;
+    context?: any;
+}
+/**
+ * Context provided to resource actions when executed on selected resources
+ */
+interface ResourceActionExecutionContext {
+    resourceType: string;
+    selectedIds: (string | number)[];
+    context?: any;
+}
+/**
+ * Handler-based action that executes a function directly.
+ * Best for simple actions and Storybook examples.
+ * Can optionally receive execution context for row-level actions.
+ */
+interface HandlerAction extends BaseAction {
+    type: "handler";
+    onExecute: (executionContext?: ActionExecutionContext) => void | Promise<void>;
+}
+/**
+ * Command-based action that executes through the command registry.
+ * Best for application-wide actions that need to be consistent and type-safe.
+ * @template TCommand - The command definition type for type-safe argument inference
+ */
+interface CommandAction<TCommand = any> extends BaseAction {
+    type: "command";
+    command: string;
+    commandArgs?: TCommand extends TypedCommandDefinition<infer TSchema> ? TSchema extends BaseSchema<any> ? Infer<TSchema> : undefined : Record<string, unknown>;
+}
+/**
+ * Resource-based action that executes on selected resources.
+ * Best for bulk operations on multiple selected items (e.g., delete multiple tickets).
+ * Requires ResourceContext to provide selected resource IDs.
+ */
+interface ResourceAction extends BaseAction {
+    type: "resource";
+    onExecute: (executionContext: ResourceActionExecutionContext) => void | Promise<void>;
+}
+/**
+ * Union type for all supported action types.
+ */
+type Action = HandlerAction | CommandAction<any> | ResourceAction;
+/**
+ * Type for action or separator - used consistently across all action components.
+ */
+type ActionOrSeparator = Action | "separator";
+
+/**
+ * Configuration for creating a resource action
+ */
+interface CreateResourceActionConfig {
+    id: string;
+    label?: string;
+    icon?: React__default.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    disabled?: boolean;
+    variant?: "default" | "destructive";
+    onExecute: (context: ResourceActionExecutionContext) => void | Promise<void>;
+}
+/**
+ * Helper function to create a type-safe resource action.
+ * Resource actions operate on selected resources and receive the resource type and selected IDs.
+ *
+ * @param config - Configuration for the resource action
+ * @returns A properly typed ResourceAction
+ *
+ * @example
+ * ```typescript
+ * const deleteTicketsAction = createResourceAction({
+ *   id: "delete-tickets",
+ *   label: "Delete Selected",
+ *   icon: TrashIcon,
+ *   variant: "destructive",
+ *   onExecute: async ({ selectedIds, context }) => {
+ *     // Bulk delete the selected tickets
+ *     await Promise.all(
+ *       selectedIds.map(id => context.http.deleteTicket({ params: { id } }))
+ *     );
+ *     showToast(`Deleted ${selectedIds.length} tickets`, "success");
+ *   },
+ * });
+ * ```
+ */
+declare function createResourceAction(config: CreateResourceActionConfig): ResourceAction;
+
+/**
+ * Hook for executing actions in a standardized way.
+ * Gracefully handles missing Nubase context (for Storybook compatibility).
+ * Also handles resource context for resource actions.
+ *
+ * @returns An object with an executeAction function
+ */
+declare function useActionExecutor(): {
+    executeAction: (action: Action) => Promise<void>;
+    /**
+     * Whether command execution is available (context is present).
+     * Useful for components that want to show different UI based on availability.
+     */
+    hasCommandSupport: boolean;
+    /**
+     * Whether resource execution is available (both contexts are present).
+     * Useful for components that want to show different UI based on availability.
+     */
+    hasResourceSupport: boolean;
+};
+
+/**
+ * Type guard to check if an action is a HandlerAction.
+ */
+declare function isHandlerAction(action: Action): action is HandlerAction;
+/**
+ * Type guard to check if an action is a CommandAction.
+ */
+declare function isCommandAction(action: Action): action is CommandAction;
+/**
+ * Factory function for creating handler-based actions.
+ */
+declare function createHandlerAction(base: BaseAction, onExecute: () => void | Promise<void>): HandlerAction;
+/**
+ * Factory function for creating type-safe command-based actions.
+ * Supports both typed command definitions and legacy string commands.
+ */
+declare function createCommandAction<TCommand extends TypedCommandDefinition<any>>(base: BaseAction, command: TCommand, commandArgs?: TCommand extends TypedCommandDefinition<infer TSchema> ? TSchema extends _nubase_core.BaseSchema<any> ? _nubase_core.Infer<TSchema> : undefined : never): CommandAction<TCommand>;
+declare function createCommandAction(base: BaseAction, command: string, commandArgs?: Record<string, unknown>): CommandAction<any>;
+/**
+ * Utility to convert a list of actions with separators into grouped structure.
+ * Splits actions at "separator" markers into separate arrays.
+ */
+declare function groupActionsBySeparators(actionsConfig: ActionOrSeparator[]): Action[][];
+
+declare class CommandRegistryImpl implements CommandRegistry {
+    private commands;
+    private context;
+    setContext(context: NubaseContextData): void;
+    register(command: TypedCommandDefinition<any>): void;
+    execute(commandId: string, args?: unknown): Promise<void>;
+    getCommand(commandId: string): TypedCommandDefinition<any> | undefined;
+    getAllCommands(): TypedCommandDefinition<any>[];
+    clear(): void;
+}
+declare const commandRegistry: CommandRegistryImpl;
+
+/**
+ * Factory function for creating type-safe command definitions.
+ *
+ * This function provides full TypeScript type inference for command arguments
+ * based on the provided schema. Use this instead of directly creating
+ * TypedCommandDefinition objects for better type safety.
+ *
+ * @param definition - The command definition with optional args schema
+ * @returns A typed command definition with inferred argument types
+ *
+ * @example
+ * ```typescript
+ * // Command with no arguments
+ * const simpleCommand = defineCommand({
+ *   id: "example.simple",
+ *   name: "Simple Command",
+ *   execute: (context) => {
+ *     // context is typed, args is undefined
+ *   },
+ * });
+ *
+ * // Command with typed arguments
+ * const typedCommand = defineCommand({
+ *   id: "example.typed",
+ *   name: "Typed Command",
+ *   argsSchema: nu.object({
+ *     resourceId: nu.string(),
+ *     count: nu.number().optional(),
+ *   }),
+ *   execute: (context, args) => {
+ *     // args is typed as { resourceId: string; count?: number | undefined }
+ *     console.log(args.resourceId); // Type-safe access
+ *   },
+ * });
+ * ```
+ */
+declare function createCommand<TArgsSchema extends BaseSchema<any> | undefined>(definition: TypedCommandDefinition<TArgsSchema>): TypedCommandDefinition<TArgsSchema>;
+
+declare const workbenchOpenResourceOperation: TypedCommandDefinition<_nubase_core.OptionalSchema<_nubase_core.ObjectSchema<{
+    resourceId: _nubase_core.OptionalSchema<_nubase_core.StringSchema>;
+    operation: _nubase_core.OptionalSchema<_nubase_core.StringSchema>;
+}, null>>>;
+
+declare const workbenchOpenResourceOperationInModal: TypedCommandDefinition<_nubase_core.OptionalSchema<_nubase_core.ObjectSchema<{
+    resourceId: _nubase_core.OptionalSchema<_nubase_core.StringSchema>;
+    operation: _nubase_core.OptionalSchema<_nubase_core.StringSchema>;
+}, null>>>;
+
+declare const workbenchRunCommand: TypedCommandDefinition<_nubase_core.BaseSchema<any> | undefined>;
+
+declare const workbenchSetTheme: TypedCommandDefinition<_nubase_core.OptionalSchema<_nubase_core.ObjectSchema<{
+    themeId: _nubase_core.OptionalSchema<_nubase_core.StringSchema>;
+}, null>>>;
+
+declare const workbenchViewHistory: TypedCommandDefinition<_nubase_core.BaseSchema<any> | undefined>;
+
+/**
+ * Centralized exports for all command definitions.
+ * This allows importing commands as a namespace: `import { commands } from "@nubase/frontend"`
+ * Usage: `commands.workbenchSetTheme`, `commands.workbenchOpenResourceOperation`, etc.
+ */
+
+declare const index_workbenchOpenResourceOperation: typeof workbenchOpenResourceOperation;
+declare const index_workbenchOpenResourceOperationInModal: typeof workbenchOpenResourceOperationInModal;
+declare const index_workbenchRunCommand: typeof workbenchRunCommand;
+declare const index_workbenchSetTheme: typeof workbenchSetTheme;
+declare const index_workbenchViewHistory: typeof workbenchViewHistory;
+declare namespace index {
+  export { index_workbenchOpenResourceOperation as workbenchOpenResourceOperation, index_workbenchOpenResourceOperationInModal as workbenchOpenResourceOperationInModal, index_workbenchRunCommand as workbenchRunCommand, index_workbenchSetTheme as workbenchSetTheme, index_workbenchViewHistory as workbenchViewHistory };
+}
+
+declare const activityIndicatorVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    color?: "primary" | "secondary" | "surface" | "surfaceVariant" | "inherit" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ActivityIndicatorProps extends VariantProps<typeof activityIndicatorVariants> {
+    className?: string;
+    "aria-label"?: string;
+}
+declare const ActivityIndicator: React__default.FC<ActivityIndicatorProps>;
+
+declare const actionBarVariants: (props?: ({
+    variant?: "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ActionBarProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof actionBarVariants> {
+    actions: ActionOrSeparator[];
+}
+declare const ActionBar: React__default.ForwardRefExoticComponent<ActionBarProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const actionBarContainerVariants: (props?: ({
+    variant?: "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ActionBarContainerProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof actionBarContainerVariants> {
+}
+declare const ActionBarContainer: React__default.ForwardRefExoticComponent<ActionBarContainerProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const buttonBarVariants: (props?: ({
+    alignment?: "center" | "left" | "right" | null | undefined;
+    variant?: "transparent" | "muted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonBarProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof buttonBarVariants> {
+}
+declare const ButtonBar: React__default.ForwardRefExoticComponent<ButtonBarProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const calloutVariants: (props?: ({
+    variant?: "info" | "danger" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CalloutProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof calloutVariants> {
+    /** The content to display in the callout */
+    children: React__default.ReactNode;
+    /** Optional icon to display */
+    icon?: React__default.ReactNode;
+}
+declare const Callout: React__default.FC<CalloutProps>;
+
+type CardProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
+type CardHeaderProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<CardHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+type CardTitleProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<CardTitleProps & React$1.RefAttributes<HTMLDivElement>>;
+type CardDescriptionProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<CardDescriptionProps & React$1.RefAttributes<HTMLDivElement>>;
+type CardActionProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const CardAction: React$1.ForwardRefExoticComponent<CardActionProps & React$1.RefAttributes<HTMLDivElement>>;
+type CardContentProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const CardContent: React$1.ForwardRefExoticComponent<CardContentProps & React$1.RefAttributes<HTMLDivElement>>;
+type CardFooterProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<CardFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+type ChartConfig = {
+    [k in string]: {
+        label?: React$1.ReactNode;
+        icon?: React$1.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+type ChartContextProps = {
+    config: ChartConfig;
+};
+declare function useChart(): ChartContextProps;
+declare const ChartContainer: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    config: ChartConfig;
+    children: React$1.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => react_jsx_runtime.JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+interface ChartTooltipContentProps extends React$1.ComponentProps<"div"> {
+    active?: boolean;
+    payload?: Array<{
+        name?: string;
+        value?: number | string;
+        dataKey?: string | number;
+        color?: string;
+        payload?: Record<string, unknown>;
+    }>;
+    label?: string;
+    labelFormatter?: (label: unknown, payload: unknown[]) => React$1.ReactNode;
+    labelClassName?: string;
+    formatter?: (value: unknown, name: unknown, item: unknown, index: number, payload: unknown) => React$1.ReactNode;
+    color?: string;
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+}
+declare const ChartTooltipContent: React$1.ForwardRefExoticComponent<Omit<ChartTooltipContentProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+interface ChartLegendContentProps extends React$1.ComponentProps<"div"> {
+    payload?: Array<{
+        value?: string;
+        dataKey?: string | number;
+        color?: string;
+    }>;
+    verticalAlign?: "top" | "bottom";
+    hideIcon?: boolean;
+    nameKey?: string;
+}
+declare const ChartLegendContent: React$1.ForwardRefExoticComponent<Omit<ChartLegendContentProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface ConnectedWidgetProps {
+    widget: WidgetDescriptor<unknown>;
+}
+/**
+ * ConnectedWidget handles data fetching and renders the appropriate content
+ * inside a DashboardWidget based on the widget type.
+ *
+ * This component:
+ * 1. Fetches data from the widget's endpoint
+ * 2. Shows loading/error states
+ * 3. Renders the appropriate content renderer based on widget type
+ * 4. Wraps everything in the DashboardWidget presentation component
+ */
+declare function ConnectedWidget({ widget }: ConnectedWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardDragConfig {
+    /** Enable dragging */
+    enabled?: boolean;
+    /** CSS selector for drag handle */
+    handle?: string;
+    /** CSS selector for elements that should not trigger drag */
+    cancel?: string;
+}
+interface DashboardResizeConfig {
+    /** Enable resizing */
+    enabled?: boolean;
+    /** Which handles to show for resizing */
+    handles?: Array<"s" | "w" | "e" | "n" | "sw" | "nw" | "se" | "ne">;
+}
+interface DashboardProps {
+    /** The layout configuration for grid items */
+    layout: Layout$1;
+    /** Callback when layout changes */
+    onLayoutChange?: (layout: Layout$1) => void;
+    /** Grid configuration */
+    gridConfig?: DashboardGridConfig;
+    /** Drag configuration */
+    dragConfig?: DashboardDragConfig;
+    /** Resize configuration */
+    resizeConfig?: DashboardResizeConfig;
+    /** Additional class name for the dashboard container */
+    className?: string;
+    /** Dashboard widget children */
+    children: React$1.ReactNode;
+}
+/**
+ * Dashboard is a grid layout container for DashboardWidget components.
+ * It uses react-grid-layout internally for drag-and-drop and resizing functionality.
+ */
+declare function Dashboard({ layout, onLayoutChange, gridConfig: gridConfigProp, dragConfig: dragConfigProp, resizeConfig: resizeConfigProp, className, children, }: DashboardProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardRendererProps {
+    /** The dashboard descriptor to render */
+    dashboard: DashboardDescriptor<any>;
+    /** Optional controlled layout state */
+    layout?: Layout$1;
+    /** Callback when layout changes */
+    onLayoutChange?: (layout: Layout$1) => void;
+    /** Additional class name for the dashboard container */
+    className?: string;
+}
+/**
+ * Renders a complete dashboard from a DashboardDescriptor configuration.
+ *
+ * This component:
+ * 1. Generates the layout from widget configurations
+ * 2. Renders each widget as a ConnectedWidget (which handles data fetching)
+ * 3. Manages layout state (controlled or uncontrolled)
+ *
+ * @example
+ * ```tsx
+ * import { analyticsDashboard } from "./dashboards/analytics";
+ *
+ * function AnalyticsPage() {
+ *   return (
+ *     <div className="p-4">
+ *       <DashboardRenderer dashboard={analyticsDashboard} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function DashboardRenderer({ dashboard, layout: controlledLayout, onLayoutChange, className, }: DashboardRendererProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardWidgetProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** The title of the widget */
+    title: string;
+    /** Optional icon component (not instantiated) shown before the title */
+    icon?: IconComponent;
+    /** Optional action elements (e.g., buttons) shown on the right side of the header */
+    action?: React$1.ReactNode;
+    /** Optional footer content */
+    footer?: React$1.ReactNode;
+    /** Whether the widget is draggable (shows drag handle) */
+    draggable?: boolean;
+    /** The widget content */
+    children: React$1.ReactNode;
+}
+/**
+ * DashboardWidget is a Widget component adapted for use inside a Dashboard.
+ * It includes a drag handle for repositioning within the grid layout.
+ */
+declare const DashboardWidget: React$1.ForwardRefExoticComponent<DashboardWidgetProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface PartialPosition {
+    readonly idx?: number | undefined;
+    readonly rowIdx?: number | undefined;
+}
+
+type DefaultColumnOptions<R, SR> = Pick<Column<R, SR>, "renderCell" | "renderHeaderCell" | "width" | "minWidth" | "maxWidth" | "resizable" | "sortable" | "draggable">;
+interface DataGridHandle {
+    element: HTMLDivElement | null;
+    scrollToCell: (position: PartialPosition) => void;
+    selectCell: (position: Position, options?: SelectCellOptions) => void;
+}
+type SharedDivProps = Pick<React.ComponentProps<"div">, "role" | "aria-label" | "aria-labelledby" | "aria-description" | "aria-describedby" | "aria-rowcount" | "className" | "style">;
+interface DataGridProps<R, SR = unknown, K extends Key = Key> extends SharedDivProps {
+    ref?: Maybe<React.Ref<DataGridHandle>>;
+    /**
+     * Grid and data Props
+     */
+    /** An array of column definitions */
+    columns: readonly ColumnOrColumnGroup<NoInfer<R>, NoInfer<SR>>[];
+    /** A function called for each rendered row that should return a plain key/value pair object */
+    rows: readonly R[];
+    /** Rows pinned at the top of the grid for summary purposes */
+    topSummaryRows?: Maybe<readonly SR[]>;
+    /** Rows pinned at the bottom of the grid for summary purposes */
+    bottomSummaryRows?: Maybe<readonly SR[]>;
+    /** Function to return a unique key/identifier for each row */
+    rowKeyGetter?: Maybe<(row: NoInfer<R>) => K>;
+    /** Callback triggered when rows are changed */
+    onRowsChange?: Maybe<(rows: NoInfer<R>[], data: RowsChangeData<NoInfer<R>, NoInfer<SR>>) => void>;
+    /**
+     * Dimensions props
+     */
+    /**
+     * Height of each row in pixels
+     * @default 35
+     */
+    rowHeight?: Maybe<number | ((row: NoInfer<R>) => number)>;
+    /**
+     * Height of the header row in pixels
+     * @default 35
+     */
+    headerRowHeight?: Maybe<number>;
+    /**
+     * Height of each summary row in pixels
+     * @default 35
+     */
+    summaryRowHeight?: Maybe<number>;
+    /** A map of column widths */
+    columnWidths?: Maybe<ColumnWidths>;
+    /** Callback triggered when column widths change */
+    onColumnWidthsChange?: Maybe<(columnWidths: ColumnWidths) => void>;
+    /**
+     * Feature props
+     */
+    /** A set of selected row keys */
+    selectedRows?: Maybe<ReadonlySet<K>>;
+    /** Function to determine if row selection is disabled for a specific row */
+    isRowSelectionDisabled?: Maybe<(row: NoInfer<R>) => boolean>;
+    /** Callback triggered when the selection changes */
+    onSelectedRowsChange?: Maybe<(selectedRows: Set<NoInfer<K>>) => void>;
+    /** An array of sorted columns */
+    sortColumns?: Maybe<readonly SortColumn[]>;
+    /** Callback triggered when sorting changes */
+    onSortColumnsChange?: Maybe<(sortColumns: SortColumn[]) => void>;
+    /** Default options applied to all columns */
+    defaultColumnOptions?: Maybe<DefaultColumnOptions<NoInfer<R>, NoInfer<SR>>>;
+    onFill?: Maybe<(event: FillEvent<NoInfer<R>>) => NoInfer<R>>;
+    /**
+     * Event props
+     */
+    /** Callback triggered when a pointer becomes active in a cell */
+    onCellMouseDown?: CellMouseEventHandler<R, SR>;
+    /** Callback triggered when a cell is clicked */
+    onCellClick?: CellMouseEventHandler<R, SR>;
+    /** Callback triggered when a cell is double-clicked */
+    onCellDoubleClick?: CellMouseEventHandler<R, SR>;
+    /** Callback triggered when a cell is right-clicked */
+    onCellContextMenu?: CellMouseEventHandler<R, SR>;
+    /** Callback triggered when a key is pressed in a cell */
+    onCellKeyDown?: Maybe<(args: CellKeyDownArgs<NoInfer<R>, NoInfer<SR>>, event: CellKeyboardEvent) => void>;
+    /** Callback triggered when a cell's content is copied */
+    onCellCopy?: Maybe<(args: CellCopyArgs<NoInfer<R>, NoInfer<SR>>, event: CellClipboardEvent) => void>;
+    /** Callback triggered when content is pasted into a cell */
+    onCellPaste?: Maybe<(args: CellPasteArgs<NoInfer<R>, NoInfer<SR>>, event: CellClipboardEvent) => NoInfer<R>>;
+    /** Function called whenever cell selection is changed */
+    onSelectedCellChange?: Maybe<(args: CellSelectArgs<NoInfer<R>, NoInfer<SR>>) => void>;
+    /** Callback triggered when the grid is scrolled */
+    onScroll?: Maybe<(event: React.UIEvent<HTMLDivElement>) => void>;
+    /** Callback triggered when column is resized */
+    onColumnResize?: Maybe<(column: CalculatedColumn<R, SR>, width: number) => void>;
+    /** Callback triggered when columns are reordered */
+    onColumnsReorder?: Maybe<(sourceColumnKey: string, targetColumnKey: string) => void>;
+    /**
+     * Toggles and modes
+     */
+    /** @default true */
+    enableVirtualization?: Maybe<boolean>;
+    /**
+     * Miscellaneous
+     */
+    /** Custom renderers for cells, rows, and other components */
+    renderers?: Maybe<Renderers<NoInfer<R>, NoInfer<SR>>>;
+    /** Function to apply custom class names to rows */
+    rowClass?: Maybe<(row: NoInfer<R>, rowIdx: number) => Maybe<string>>;
+    /** Custom class name for the header row */
+    headerRowClass?: Maybe<string>;
+    /**
+     * Text direction of the grid ('ltr' or 'rtl')
+     * @default 'ltr'
+     */
+    direction?: Maybe<Direction>;
+    "data-testid"?: Maybe<string>;
+    "data-cy"?: Maybe<string>;
+}
+/**
+ * Main API Component to render a data grid of rows and columns
+ *
+ * @example
+ *
+ * <DataGrid columns={columns} rows={rows} />
+ */
+declare function DataGrid<R, SR = unknown, K extends Key = Key>(props: DataGridProps<R, SR, K>): react_jsx_runtime.JSX.Element;
+
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type Maybe<T> = T | undefined | null;
+interface Column<TRow, TSummaryRow = unknown> {
+    /** The name of the column. Displayed in the header cell by default */
+    readonly name: string | ReactElement;
+    /** A unique key to distinguish each column */
+    readonly key: string;
+    /**
+     * Column width. If not specified, it will be determined automatically based on grid width and specified widths of other columns
+     * @default 'auto'
+     */
+    readonly width?: Maybe<number | string>;
+    /**
+     * Minimum column width in pixels
+     * @default 50
+     */
+    readonly minWidth?: Maybe<number>;
+    /** Maximum column width in pixels */
+    readonly maxWidth?: Maybe<number>;
+    /** Class name(s) for the cell */
+    readonly cellClass?: Maybe<string | ((row: TRow) => Maybe<string>)>;
+    /** Class name(s) for the header cell */
+    readonly headerCellClass?: Maybe<string>;
+    /** Class name(s) for the summary cell */
+    readonly summaryCellClass?: Maybe<string | ((row: TSummaryRow) => Maybe<string>)>;
+    /** Render function to render the content of cells */
+    readonly renderCell?: Maybe<(props: RenderCellProps<TRow, TSummaryRow>) => ReactNode>;
+    /** Render function to render the content of the header cell */
+    readonly renderHeaderCell?: Maybe<(props: RenderHeaderCellProps<TRow, TSummaryRow>) => ReactNode>;
+    /** Render function to render the content of summary cells */
+    readonly renderSummaryCell?: Maybe<(props: RenderSummaryCellProps<TSummaryRow, TRow>) => ReactNode>;
+    /** Render function to render the content of group cells */
+    readonly renderGroupCell?: Maybe<(props: RenderGroupCellProps<TRow, TSummaryRow>) => ReactNode>;
+    /** Render function to render the content of edit cells. When set, the column is automatically set to be editable */
+    readonly renderEditCell?: Maybe<(props: RenderEditCellProps<TRow, TSummaryRow>) => ReactNode>;
+    /** Enables cell editing. If set and no editor property specified, then a textinput will be used as the cell editor */
+    readonly editable?: Maybe<boolean | ((row: TRow) => boolean)>;
+    readonly colSpan?: Maybe<(args: ColSpanArgs<TRow, TSummaryRow>) => Maybe<number>>;
+    /** Determines whether column is frozen */
+    readonly frozen?: Maybe<boolean>;
+    /** Enable resizing of the column */
+    readonly resizable?: Maybe<boolean>;
+    /** Enable sorting of the column */
+    readonly sortable?: Maybe<boolean>;
+    /** Enable dragging of the column */
+    readonly draggable?: Maybe<boolean>;
+    /** Sets the column sort order to be descending instead of ascending the first time the column is sorted */
+    readonly sortDescendingFirst?: Maybe<boolean>;
+    /** Options for cell editing */
+    readonly editorOptions?: Maybe<{
+        /**
+         * Render the cell content in addition to the edit cell.
+         * Enable this option when the editor is rendered outside the grid, like a modal for example.
+         * By default, the cell content is not rendered when the edit cell is open.
+         * @default false
+         */
+        readonly displayCellContent?: Maybe<boolean>;
+        /**
+         * Commit changes when clicking outside the cell
+         * @default true
+         */
+        readonly commitOnOutsideClick?: Maybe<boolean>;
+        /**
+         * Close the editor when the row changes externally
+         * @default true
+         */
+        readonly closeOnExternalRowChange?: Maybe<boolean>;
+    }>;
+}
+interface CalculatedColumn<TRow, TSummaryRow = unknown> extends Column<TRow, TSummaryRow> {
+    readonly parent: CalculatedColumnParent<TRow, TSummaryRow> | undefined;
+    readonly idx: number;
+    readonly level: number;
+    readonly width: number | string;
+    readonly minWidth: number;
+    readonly maxWidth: number | undefined;
+    readonly resizable: boolean;
+    readonly sortable: boolean;
+    readonly draggable: boolean;
+    readonly frozen: boolean;
+    readonly renderCell: (props: RenderCellProps<TRow, TSummaryRow>) => ReactNode;
+    readonly renderHeaderCell: (props: RenderHeaderCellProps<TRow, TSummaryRow>) => ReactNode;
+}
+interface ColumnGroup<R, SR = unknown> {
+    /** The name of the column group, it will be displayed in the header cell */
+    readonly name: string | ReactElement;
+    readonly headerCellClass?: Maybe<string>;
+    readonly children: readonly ColumnOrColumnGroup<R, SR>[];
+}
+interface CalculatedColumnParent<R, SR> {
+    readonly name: string | ReactElement;
+    readonly parent: CalculatedColumnParent<R, SR> | undefined;
+    readonly idx: number;
+    readonly colSpan: number;
+    readonly level: number;
+    readonly headerCellClass?: Maybe<string>;
+}
+type ColumnOrColumnGroup<R, SR = unknown> = Column<R, SR> | ColumnGroup<R, SR>;
+type CalculatedColumnOrColumnGroup<R, SR> = CalculatedColumnParent<R, SR> | CalculatedColumn<R, SR>;
+interface Position {
+    readonly idx: number;
+    readonly rowIdx: number;
+}
+interface RenderCellProps<TRow, TSummaryRow = unknown> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+    rowIdx: number;
+    isCellEditable: boolean;
+    tabIndex: number;
+    onRowChange: (row: TRow) => void;
+}
+interface RenderSummaryCellProps<TSummaryRow, TRow = unknown> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TSummaryRow;
+    tabIndex: number;
+}
+interface RenderGroupCellProps<TRow, TSummaryRow = unknown> {
+    groupKey: unknown;
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: GroupRow<TRow>;
+    childRows: readonly TRow[];
+    isExpanded: boolean;
+    tabIndex: number;
+    toggleGroup: () => void;
+}
+interface RenderEditCellProps<TRow, TSummaryRow = unknown> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+    rowIdx: number;
+    onRowChange: (row: TRow, commitChanges?: boolean) => void;
+    onClose: (commitChanges?: boolean, shouldFocusCell?: boolean) => void;
+}
+interface RenderHeaderCellProps<TRow, TSummaryRow = unknown> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    sortDirection: SortDirection | undefined;
+    priority: number | undefined;
+    tabIndex: number;
+}
+interface BaseCellRendererProps<TRow, TSummaryRow = unknown> extends Omit$1<React.ComponentProps<"div">, "children">, Pick<DataGridProps<TRow, TSummaryRow>, "onCellMouseDown" | "onCellClick" | "onCellDoubleClick" | "onCellContextMenu"> {
+    rowIdx: number;
+    selectCell: (position: Position, options?: SelectCellOptions) => void;
+}
+interface CellRendererProps<TRow, TSummaryRow> extends BaseCellRendererProps<TRow, TSummaryRow> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+    colSpan: number | undefined;
+    isDraggedOver: boolean;
+    isCellSelected: boolean;
+    onRowChange: (column: CalculatedColumn<TRow, TSummaryRow>, newRow: TRow) => void;
+}
+type CellEvent<E extends React.SyntheticEvent<HTMLDivElement>> = E & {
+    preventGridDefault: () => void;
+    isGridDefaultPrevented: () => boolean;
+};
+type CellMouseEvent = CellEvent<React.MouseEvent<HTMLDivElement>>;
+type CellKeyboardEvent = CellEvent<React.KeyboardEvent<HTMLDivElement>>;
+type CellClipboardEvent = React.ClipboardEvent<HTMLDivElement>;
+interface CellMouseArgs<TRow, TSummaryRow = unknown> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+    rowIdx: number;
+    selectCell: (enableEditor?: boolean) => void;
+}
+interface SelectCellKeyDownArgs<TRow, TSummaryRow = unknown> {
+    mode: "SELECT";
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+    rowIdx: number;
+    selectCell: (position: Position, options?: SelectCellOptions) => void;
+}
+interface EditCellKeyDownArgs<TRow, TSummaryRow = unknown> {
+    mode: "EDIT";
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+    rowIdx: number;
+    navigate: () => void;
+    onClose: (commitChanges?: boolean, shouldFocusCell?: boolean) => void;
+}
+type CellKeyDownArgs<TRow, TSummaryRow = unknown> = SelectCellKeyDownArgs<TRow, TSummaryRow> | EditCellKeyDownArgs<TRow, TSummaryRow>;
+interface CellSelectArgs<TRow, TSummaryRow = unknown> {
+    rowIdx: number;
+    row: TRow | undefined;
+    column: CalculatedColumn<TRow, TSummaryRow>;
+}
+type CellMouseEventHandler<R, SR> = Maybe<(args: CellMouseArgs<NoInfer<R>, NoInfer<SR>>, event: CellMouseEvent) => void>;
+interface BaseRenderRowProps<TRow, TSummaryRow = unknown> extends BaseCellRendererProps<TRow, TSummaryRow> {
+    viewportColumns: readonly CalculatedColumn<TRow, TSummaryRow>[];
+    rowIdx: number;
+    selectedCellIdx: number | undefined;
+    isRowSelectionDisabled: boolean;
+    isRowSelected: boolean;
+    gridRowStart: number;
+}
+interface RenderRowProps<TRow, TSummaryRow = unknown> extends BaseRenderRowProps<TRow, TSummaryRow> {
+    row: TRow;
+    lastFrozenColumnIndex: number;
+    draggedOverCellIdx: number | undefined;
+    selectedCellEditor: ReactElement<RenderEditCellProps<TRow>> | undefined;
+    onRowChange: (column: CalculatedColumn<TRow, TSummaryRow>, rowIdx: number, newRow: TRow) => void;
+    rowClass: Maybe<(row: TRow, rowIdx: number) => Maybe<string>>;
+}
+interface RowsChangeData<R, SR = unknown> {
+    indexes: number[];
+    column: CalculatedColumn<R, SR>;
+}
+interface SelectRowEvent<TRow> {
+    row: TRow;
+    checked: boolean;
+    isShiftClick: boolean;
+}
+interface SelectHeaderRowEvent {
+    checked: boolean;
+}
+interface FillEvent<TRow> {
+    columnKey: string;
+    sourceRow: TRow;
+    targetRow: TRow;
+}
+interface CellCopyPasteArgs<TRow, TSummaryRow = unknown> {
+    column: CalculatedColumn<TRow, TSummaryRow>;
+    row: TRow;
+}
+type CellCopyArgs<TRow, TSummaryRow = unknown> = CellCopyPasteArgs<TRow, TSummaryRow>;
+type CellPasteArgs<TRow, TSummaryRow = unknown> = CellCopyPasteArgs<TRow, TSummaryRow>;
+interface GroupRow<TRow> {
+    readonly childRows: readonly TRow[];
+    readonly id: string;
+    readonly parentId: unknown;
+    readonly groupKey: unknown;
+    readonly isExpanded: boolean;
+    readonly level: number;
+    readonly posInSet: number;
+    readonly setSize: number;
+    readonly startRowIndex: number;
+}
+interface SortColumn {
+    readonly columnKey: string;
+    readonly direction: SortDirection;
+}
+type SortDirection = "ASC" | "DESC";
+type ColSpanArgs<TRow, TSummaryRow> = {
+    type: "HEADER";
+} | {
+    type: "ROW";
+    row: TRow;
+} | {
+    type: "SUMMARY";
+    row: TSummaryRow;
+};
+type RowHeightArgs<TRow> = {
+    type: "ROW";
+    row: TRow;
+} | {
+    type: "GROUP";
+    row: GroupRow<TRow>;
+};
+interface RenderSortIconProps {
+    sortDirection: SortDirection | undefined;
+}
+interface RenderSortPriorityProps {
+    priority: number | undefined;
+}
+interface RenderSortStatusProps extends RenderSortIconProps, RenderSortPriorityProps {
+}
+interface RenderCheckboxProps extends Pick<React.ComponentProps<"input">, "aria-label" | "aria-labelledby" | "checked" | "tabIndex" | "disabled"> {
+    indeterminate?: boolean | undefined;
+    onChange: (checked: boolean, shift: boolean) => void;
+}
+interface Renderers<TRow, TSummaryRow> {
+    renderCell?: Maybe<(key: Key, props: CellRendererProps<TRow, TSummaryRow>) => ReactNode>;
+    renderCheckbox?: Maybe<(props: RenderCheckboxProps) => ReactNode>;
+    renderRow?: Maybe<(key: Key, props: RenderRowProps<TRow, TSummaryRow>) => ReactNode>;
+    renderSortStatus?: Maybe<(props: RenderSortStatusProps) => ReactNode>;
+    noRowsFallback?: Maybe<ReactNode>;
+}
+interface SelectCellOptions {
+    enableEditor?: Maybe<boolean>;
+    shouldFocusCell?: Maybe<boolean>;
+}
+interface ColumnWidth {
+    readonly type: "resized" | "measured";
+    readonly width: number;
+}
+type ColumnWidths = ReadonlyMap<string, ColumnWidth>;
+type Direction = "ltr" | "rtl";
+
+declare const CellComponent: <R, SR>(props: CellRendererProps<R, SR>) => React.JSX.Element;
+
+declare const SELECT_COLUMN_KEY = "rdg-select-column";
+declare const SelectColumn: Column<any, any>;
+declare const ACTION_COLUMN_KEY = "rdg-action-column";
+/**
+ * Creates an action column for a DataGrid that displays a dropdown menu with actions for each row.
+ * @param actions - Array of actions or separators to display for each row
+ * @param context - Optional context to pass to actions for HTTP calls and other operations
+ * @param idField - Optional ID field name for resource actions (defaults to "id")
+ * @returns Column configuration for the DataGrid
+ */
+declare function createActionColumn<R>(actions: ActionOrSeparator[], context?: any, idField?: string): Column<R, any>;
+
+interface ActionCellFormatterProps<R> {
+    actions: ActionOrSeparator[];
+    row?: R;
+    context?: any;
+}
+declare function ActionCellFormatter<R>({ row, actions, context, idField, }: ActionCellFormatterProps<R> & {
+    idField?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare function ActionCellRendererCell<R>(props: RenderCellProps<R> & {
+    actions: ActionOrSeparator[];
+    context?: any;
+    idField?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function ActionCellRendererGroup<R>(_props: RenderGroupCellProps<R> & {
+    actions: ActionOrSeparator[];
+    context?: any;
+}): null;
+
+declare function renderCheckbox({ onChange, indeterminate, ...props }: RenderCheckboxProps): react_jsx_runtime.JSX.Element;
+
+declare function renderToggleGroup<R, SR>(props: RenderGroupCellProps<R, SR>): react_jsx_runtime.JSX.Element;
+declare function ToggleGroup<R, SR>({ groupKey, isExpanded, tabIndex, toggleGroup, }: RenderGroupCellProps<R, SR>): react_jsx_runtime.JSX.Element;
+
+declare function renderValue<R, SR>(props: RenderCellProps<R, SR>): React$1.ReactNode;
+
+type SharedInputProps = Pick<RenderCheckboxProps, "disabled" | "tabIndex" | "aria-label" | "aria-labelledby" | "indeterminate" | "onChange">;
+interface SelectCellFormatterProps extends SharedInputProps {
+    value: boolean;
+}
+declare function SelectCellFormatter({ value, tabIndex, indeterminate, disabled, onChange, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, }: SelectCellFormatterProps): React$1.ReactNode;
+
+declare const DataGridDefaultRenderersContext: React$1.Context<Maybe<Renderers<any, any>>>;
+
+declare function textEditor<TRow, TSummaryRow>({ row, column, onRowChange, onClose, }: RenderEditCellProps<TRow, TSummaryRow>): react_jsx_runtime.JSX.Element;
+
+declare function useRowSelection(): {
+    isRowSelectionDisabled: boolean;
+    isRowSelected: boolean;
+    onRowSelectionChange: (selectRowEvent: SelectRowEvent<any>) => void;
+};
+declare function useHeaderRowSelection(): {
+    isIndeterminate: boolean;
+    isRowSelected: boolean;
+    onRowSelectionChange: (selectRowEvent: SelectHeaderRowEvent) => void;
+};
+
+declare const RowComponent: <R, SR>(props: RenderRowProps<R, SR>) => React.JSX.Element;
+
+declare function renderHeaderCell<R, SR>({ column, sortDirection, priority, }: RenderHeaderCellProps<R, SR>): string | react_jsx_runtime.JSX.Element;
+
+declare function renderSortIcon({ sortDirection }: RenderSortIconProps): react_jsx_runtime.JSX.Element | null;
+declare function renderSortPriority({ priority }: RenderSortPriorityProps): number | undefined;
+
+interface TreeDataGridProps<R, SR = unknown, K extends Key = Key> extends Omit$1<DataGridProps<R, SR, K>, "columns" | "role" | "aria-rowcount" | "rowHeight" | "onFill" | "isRowSelectionDisabled"> {
+    columns: readonly Column<NoInfer<R>, NoInfer<SR>>[];
+    rowHeight?: Maybe<number | ((args: RowHeightArgs<NoInfer<R>>) => number)>;
+    groupBy: readonly string[];
+    rowGrouper: (rows: readonly NoInfer<R>[], columnKey: string) => Record<string, readonly NoInfer<R>[]>;
+    expandedGroupIds: ReadonlySet<unknown>;
+    onExpandedGroupIdsChange: (expandedGroupIds: Set<unknown>) => void;
+    groupIdGetter?: Maybe<(groupKey: string, parentId?: string) => string>;
+}
+declare function TreeDataGrid<R, SR = unknown, K extends Key = Key>({ columns: rawColumns, rows: rawRows, rowHeight: rawRowHeight, rowKeyGetter: rawRowKeyGetter, onCellKeyDown: rawOnCellKeyDown, onCellCopy: rawOnCellCopy, onCellPaste: rawOnCellPaste, onRowsChange, selectedRows: rawSelectedRows, onSelectedRowsChange: rawOnSelectedRowsChange, renderers, groupBy: rawGroupBy, rowGrouper, expandedGroupIds, onExpandedGroupIdsChange, groupIdGetter: rawGroupIdGetter, ...props }: TreeDataGridProps<R, SR, K>): react_jsx_runtime.JSX.Element;
+
+type DataStateProps = {
+    /** Whether data is currently loading */
+    isLoading?: boolean;
+    /** Error that occurred during data fetching */
+    error?: Error | null;
+    /** Whether the data set is empty (after successful load) */
+    isEmpty?: boolean;
+    /** Message to display when data is empty */
+    emptyMessage?: string;
+    /** Aria label for the loading indicator */
+    loadingLabel?: string;
+    /** Message to display when there's an error */
+    errorMessage?: string;
+    /** Content to render when data is successfully loaded */
+    children: ReactNode;
+};
+/**
+ * A component that handles common data fetching states: loading, error, and empty.
+ * Renders children only when data is successfully loaded and not empty.
+ *
+ * @example
+ * ```tsx
+ * <DataState
+ *   isLoading={isLoading}
+ *   error={error}
+ *   isEmpty={data.length === 0}
+ *   emptyMessage="No items found"
+ *   loadingLabel="Loading search results..."
+ * >
+ *   <DataGrid data={data} />
+ * </DataState>
+ * ```
+ */
+declare const DataState: FC<DataStateProps>;
+
+interface DockProps {
+    center: React__default.ReactNode;
+    left?: React__default.ReactNode;
+    right?: React__default.ReactNode;
+    top?: React__default.ReactNode;
+    defaultLeftWidth?: number;
+    defaultRightWidth?: number;
+}
+declare const Dock: React__default.FC<DockProps>;
+
+interface ActionDropdownMenuProps {
+    trigger: React__default.ReactNode;
+    actions: ActionOrSeparator[];
+    className?: string;
+    contentClassName?: string;
+    /**
+     * Side offset for the dropdown menu content.
+     * @default 4
+     */
+    sideOffset?: number;
+    /**
+     * Whether the menu should close when an action is executed.
+     * @default true
+     */
+    closeOnAction?: boolean;
+}
+/**
+ * A dropdown menu component that takes standardized actions and renders them as menu items.
+ * Supports both command and handler actions, with automatic action execution.
+ * Actions can be grouped using "separator" entries.
+ */
+declare const ActionDropdownMenu: React__default.ForwardRefExoticComponent<ActionDropdownMenuProps & React__default.RefAttributes<never>>;
+
+declare function DropdownMenu({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, side, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSub({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
+
+interface ThemeToggleProps {
+    className?: string;
+    defaultTheme: "light" | "dark";
+}
+declare const ThemeToggle: ({ className }: ThemeToggleProps) => react_jsx_runtime.JSX.Element;
+
+type ToastType = "default" | "error";
+type ToastPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
+interface ToastData {
+    id: string;
+    message: ReactNode;
+    type: ToastType;
+    duration?: number;
+    closable?: boolean;
+    promise?: Promise<any>;
+    loadingText?: ReactNode;
+}
+interface ToastOptions {
+    duration?: number;
+    closable?: boolean;
+}
+interface PromiseToastOptions extends ToastOptions {
+    loadingText?: ReactNode;
+}
+interface PromiseResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: any;
+}
+interface PromiseToastConfig {
+    message: ReactNode;
+    type: ToastType;
+    duration?: number;
+}
+type PromiseToastCallback<T = any> = (result: PromiseResult<T>) => PromiseToastConfig;
+interface ToastContextType {
+    toasts: ToastData[];
+    addToast: (message: ReactNode, type: ToastType, options?: ToastOptions) => string;
+    addPromiseToast: <T>(promise: Promise<T>, callback: PromiseToastCallback<T>, options?: PromiseToastOptions) => string;
+    removeToast: (id: string) => void;
+    updateToast: (id: string, updates: Partial<ToastData>) => void;
+}
+
+interface ToastProps {
+    toast: ToastData;
+    onClose: () => void;
+}
+declare const Toast: FC<ToastProps>;
+
+interface ToastContainerProps {
+    className?: string;
+}
+declare const ToastContainer: FC<ToastContainerProps>;
+
+declare const useToast: () => ToastContextType;
+interface ToastProviderProps {
+    children: ReactNode;
+}
+declare const ToastProvider: ({ children }: ToastProviderProps) => react_jsx_runtime.JSX.Element;
+
+declare const showToast: (message: ReactNode, type?: ToastType, options?: ToastOptions) => string;
+declare const showPromiseToast: <T>(promise: Promise<T>, callback: PromiseToastCallback<T>, options?: PromiseToastOptions) => string;
+
+interface PatchResult {
+    success: boolean;
+    errors?: string[];
+}
+
+interface FormFieldRendererProps {
+    schema: BaseSchema<any>;
+    fieldState: AnyFieldApi;
+    metadata: SchemaMetadata<any>;
+    mode?: "edit" | "view" | "patch";
+    onPatch?: (value: any, fieldState?: AnyFieldApi) => Promise<PatchResult>;
+}
+declare const FormFieldRenderer: React__default.FC<FormFieldRendererProps>;
+
+type FormValidationErrorsProps = {
+    form: ReactFormExtendedApi<any, any, any, any, any, any, any, any, any, any, any, any>;
+    className?: string;
+    testId?: string;
+};
+/**
+ * Component to display form-level validation errors.
+ * Subscribes to form state and displays onSubmit errors.
+ */
+declare const FormValidationErrors: React__default.FC<FormValidationErrorsProps>;
+
+interface SchemaFormProps extends React__default.FormHTMLAttributes<HTMLFormElement> {
+    form: SchemaFormConfiguration<any>;
+    className?: string;
+    children?: React__default.ReactNode;
+    onSubmit?: (e: React__default.FormEvent) => void;
+}
+declare const SchemaForm: React__default.ForwardRefExoticComponent<SchemaFormProps & React__default.RefAttributes<HTMLFormElement>>;
+
+interface SchemaFormButtonBarProps {
+    form: SchemaFormConfiguration<any>;
+    submitText?: string;
+    isComputing?: boolean;
+    className?: string;
+    alignment?: "left" | "center" | "right";
+    variant?: "transparent" | "muted";
+}
+declare const SchemaFormButtonBar: React__default.FC<SchemaFormButtonBarProps>;
+
+type SchemaFormValidationErrorsProps = {
+    form: SchemaFormConfiguration<any>;
+    className?: string;
+};
+/**
+ * Component to display form-level validation errors for SchemaForm.
+ * Only renders in edit/create modes, not in view mode.
+ */
+declare const SchemaFormValidationErrors: React__default.FC<SchemaFormValidationErrorsProps>;
+
+declare const buttonVariants: (props?: ({
+    variant?: "secondary" | "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React__default.ComponentProps<"button">, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    isLoading?: boolean;
+}
+declare const Button: React__default.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface CheckboxProps extends React$1.ComponentProps<typeof CheckboxPrimitive.Root> {
+    hasError?: boolean;
+}
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const searchTextInputVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface SearchTextInputProps extends Omit<React__default.ComponentProps<"input">, "size">, VariantProps<typeof searchTextInputVariants> {
+    hasError?: boolean;
+}
+declare const SearchTextInput: React__default.ForwardRefExoticComponent<Omit<SearchTextInputProps, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
+
+declare const selectVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface SelectOption<T = unknown> {
+    value: T;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectProps<T = unknown> extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "onChange" | "onSelect">, VariantProps<typeof selectVariants> {
+    options: SelectOption<T>[];
+    value?: T;
+    onChange?: (value: T | null) => void;
+    onSelectionChange?: (selectedItem: SelectOption<T> | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    hasError?: boolean;
+    loading?: boolean;
+    loadingMessage?: string;
+    emptyMessage?: string;
+    clearable?: boolean;
+    searchable?: boolean;
+    filterOptions?: (options: SelectOption<T>[], inputValue: string) => SelectOption<T>[];
+}
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps<any> & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const textInputVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface TextInputProps extends Omit<React__default.ComponentProps<"input">, "size">, VariantProps<typeof textInputVariants> {
+    hasError?: boolean;
+}
+declare const TextInput: React__default.ForwardRefExoticComponent<Omit<TextInputProps, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
+
+interface FormControlProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    required?: boolean;
+    children: React__default.ReactElement<{
+        id?: string;
+    }>;
+    field?: AnyFieldApi;
+}
+declare const FormControl: React__default.ForwardRefExoticComponent<FormControlProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const labelVariants: (props?: ({
+    variant?: "default" | "muted" | "required" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface LabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
+    required?: boolean;
+}
+declare const Label: React__default.ForwardRefExoticComponent<LabelProps & React__default.RefAttributes<HTMLLabelElement>>;
+
+interface SelectionRange {
+    start: number;
+    end: number;
+}
+interface TextState {
+    text: string;
+    selection: SelectionRange;
+}
+interface TextController {
+    replaceSelection(text: string): TextState;
+    setSelectionRange(selection: SelectionRange): TextState;
+    getState(): TextState;
+}
+interface ExecuteOptions {
+    initialState: TextState;
+    textApi: TextController;
+}
+interface MarkdownCommand {
+    shouldUndo?: (options: Pick<ExecuteOptions, "initialState">) => boolean;
+    execute: (options: ExecuteOptions) => void;
+    undo?: (options: ExecuteOptions) => void;
+}
+
+declare const boldCommand: MarkdownCommand;
+declare const italicCommand: MarkdownCommand;
+declare const strikethroughCommand: MarkdownCommand;
+declare const codeCommand: MarkdownCommand;
+declare const headingCommand: (level: number) => MarkdownCommand;
+declare const linkCommand: MarkdownCommand;
+declare const imageCommand: MarkdownCommand;
+declare const quoteCommand: MarkdownCommand;
+declare const codeBlockCommand: MarkdownCommand;
+declare const unorderedListCommand: MarkdownCommand;
+declare const orderedListCommand: MarkdownCommand;
+declare const checkListCommand: MarkdownCommand;
+
+interface MarkdownTextAreaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    className?: string;
+}
+interface MarkdownTextAreaHandle {
+    executeCommand: (command: MarkdownCommand) => void;
+    getTextController: () => TextController;
+}
+declare const MarkdownTextArea: React__default.ForwardRefExoticComponent<MarkdownTextAreaProps & React__default.RefAttributes<MarkdownTextAreaHandle>>;
+
+type BreadcrumbProps = React__default.ComponentProps<"nav">;
+declare function Breadcrumb({ ...props }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+type BreadcrumbListProps = React__default.ComponentProps<"ol">;
+declare function BreadcrumbList({ className, ...props }: BreadcrumbListProps): react_jsx_runtime.JSX.Element;
+type BreadcrumbItemProps = React__default.ComponentProps<"li">;
+declare function BreadcrumbItem({ className, ...props }: BreadcrumbItemProps): react_jsx_runtime.JSX.Element;
+type BreadcrumbLinkProps = React__default.ComponentProps<"a">;
+declare function BreadcrumbLink({ className, ...props }: BreadcrumbLinkProps): react_jsx_runtime.JSX.Element;
+type BreadcrumbPageProps = React__default.ComponentProps<"span">;
+declare function BreadcrumbPage({ className, ...props }: BreadcrumbPageProps): react_jsx_runtime.JSX.Element;
+type BreadcrumbSeparatorProps = React__default.ComponentProps<"li"> & {
+    children?: React__default.ReactNode;
+};
+declare function BreadcrumbSeparator({ children, className, ...props }: BreadcrumbSeparatorProps): react_jsx_runtime.JSX.Element;
+type BreadcrumbEllipsisProps = React__default.ComponentProps<"span">;
+declare function BreadcrumbEllipsis({ className, ...props }: BreadcrumbEllipsisProps): react_jsx_runtime.JSX.Element;
+
+type BreadcrumbBarProps = {
+    items: BreadcrumbItem$1[];
+    className?: string;
+};
+declare const BreadcrumbBar: FC<BreadcrumbBarProps>;
+
+interface MainNavProps extends React.HTMLAttributes<HTMLElement> {
+    items: MenuItem[];
+    searchPlaceholder?: string;
+}
+declare const MainNav: React$1.ForwardRefExoticComponent<MainNavProps & React$1.RefAttributes<HTMLElement>>;
+
+interface NavItem {
+    id: string;
+    label: string;
+    children?: NavItem[];
+    href?: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    badge?: string | number;
+}
+
+interface NavItemsProps {
+    items: NavItem[];
+    level?: number;
+    expandedItems: string[];
+    activeItemId?: string;
+    onToggle: (id: string) => void;
+    onItemClick?: (item: NavItem) => void;
+}
+declare const NavItems: FC<NavItemsProps>;
+
+declare const flattenNavItems: (items: NavItem[], level?: number) => (NavItem & {
+    level: number;
+})[];
+declare const filterNavItems: (items: NavItem[], query: string) => NavItem[];
+
+type ControllableSearchableTreeProps = {
+    items: MenuItem[];
+    placeHolder: string;
+    height?: "full" | number | string;
+    selectedItemId: string;
+    onSelectionChange: (itemId: string) => void;
+};
+declare const ControllableSearchableTree: React$1.ForwardRefExoticComponent<ControllableSearchableTreeProps & React$1.RefAttributes<HTMLInputElement>>;
+
+type SearchableTreeNavigatorProps = {
+    items: MenuItem[];
+    placeHolder: string;
+    height?: "full" | number | string;
+    /** Test ID for the navigator container */
+    "data-testid"?: string;
+};
+declare const SearchableTreeNavigator: React$1.ForwardRefExoticComponent<SearchableTreeNavigatorProps & React$1.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Internal flattened representation of a MenuItem for rendering.
+ * Adds hierarchy metadata needed for tree display.
+ */
+interface FlatMenuItem extends MenuItem {
+    level: number;
+    parentId?: string;
+    isExpanded?: boolean;
+    hasChildren: boolean;
+}
+interface MenuItemComponentProps {
+    item: FlatMenuItem;
+    index: number;
+    isSelected: boolean;
+    onToggleExpanded: (itemId: string) => void;
+    itemRef: (el: HTMLButtonElement | null) => void;
+    "data-testid"?: string;
+}
+declare const MenuItemComponent: ({ item, isSelected, onToggleExpanded, itemRef, "data-testid": testId, }: MenuItemComponentProps) => react_jsx_runtime.JSX.Element;
+/** @deprecated Use MenuItem from '../../menu/types' instead */
+type TreeNavigatorItem = MenuItem;
+/** @deprecated Use FlatMenuItem instead */
+type FlatItem = FlatMenuItem;
+
+interface TreeNavigatorProps {
+    items: MenuItem[];
+    searchInputRef?: RefObject<HTMLInputElement>;
+    selectedItemId?: string;
+    onSelectionChange?: (itemId: string) => void;
+    /** Test ID for the navigator container */
+    "data-testid"?: string;
+}
+declare const TreeNavigator: ({ items, searchInputRef, "data-testid": testId, }: TreeNavigatorProps) => react_jsx_runtime.JSX.Element;
+/** @deprecated Use TreeNavigator instead */
+declare const ListNavigator: ({ items, searchInputRef, "data-testid": testId, }: TreeNavigatorProps) => react_jsx_runtime.JSX.Element;
+/** @deprecated Use MenuItem from '../../menu/types' instead */
+type ListNavigatorItem = MenuItem;
+type ListNavigatorProps = TreeNavigatorProps;
+
+type NubaseAppProps = {
+    config: NubaseFrontendConfig;
+};
+declare const NubaseApp: FC<NubaseAppProps>;
+
+declare function Pagination({ className, ...props }: React$1.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
+declare function PaginationContent({ className, ...props }: React$1.ComponentProps<"ul">): react_jsx_runtime.JSX.Element;
+declare function PaginationItem({ ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<React$1.ComponentProps<typeof Button>, "variant"> & React$1.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, variant, ...props }: PaginationLinkProps): react_jsx_runtime.JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
+declare function PaginationNext({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+interface EnhancedPaginationProps extends React$1.HTMLAttributes<HTMLElement> {
+    currentPage: number;
+    totalPages: number;
+    pageSize: number;
+    totalItems: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    pageSizeOptions?: number[];
+    showPageSizeSelector?: boolean;
+    showInfo?: boolean;
+}
+declare const EnhancedPagination: React$1.ForwardRefExoticComponent<EnhancedPaginationProps & React$1.RefAttributes<HTMLElement>>;
+
+declare function Table({ className, ...props }: React$1.ComponentProps<"table">): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ className, ...props }: React$1.ComponentProps<"thead">): react_jsx_runtime.JSX.Element;
+declare function TableBody({ className, ...props }: React$1.ComponentProps<"tbody">): react_jsx_runtime.JSX.Element;
+declare function TableFooter({ className, ...props }: React$1.ComponentProps<"tfoot">): react_jsx_runtime.JSX.Element;
+declare function TableRow({ className, ...props }: React$1.ComponentProps<"tr">): react_jsx_runtime.JSX.Element;
+declare function TableHead({ className, ...props }: React$1.ComponentProps<"th">): react_jsx_runtime.JSX.Element;
+declare function TableCell({ className, ...props }: React$1.ComponentProps<"td">): react_jsx_runtime.JSX.Element;
+declare function TableCaption({ className, ...props }: React$1.ComponentProps<"caption">): react_jsx_runtime.JSX.Element;
+
+type TabsProps = React$1.ComponentProps<typeof TabsPrimitive.Root>;
+declare function Tabs({ className, ...props }: TabsProps): react_jsx_runtime.JSX.Element;
+type TabsListProps = React$1.ComponentProps<typeof TabsPrimitive.List>;
+declare function TabsList({ className, ...props }: TabsListProps): react_jsx_runtime.JSX.Element;
+type TabsTriggerProps = React$1.ComponentProps<typeof TabsPrimitive.Trigger>;
+declare function TabsTrigger({ className, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+type TabsContentProps = React$1.ComponentProps<typeof TabsPrimitive.Content>;
+declare function TabsContent({ className, ...props }: TabsContentProps): react_jsx_runtime.JSX.Element;
+
+interface SearchBarProps extends Omit<React__default.ComponentProps<"button">, "onClick"> {
+    context: NubaseContextData;
+    placeholder?: string;
+}
+/**
+ * SearchBar component that triggers the command palette when clicked.
+ * Provides a unified search interface for all commands in the application.
+ */
+declare const SearchBar: React__default.ForwardRefExoticComponent<Omit<SearchBarProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface TopBarProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    context: NubaseContextData;
+}
+/**
+ * TopBar component that provides global search and actions.
+ * Contains a SearchBar for command search and ActionBar for global actions.
+ */
+declare const TopBar: React__default.ForwardRefExoticComponent<TopBarProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface UserAvatarProps {
+    /** User's display name or username */
+    name: string;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * Get initials from a name (up to 2 characters).
+ * Examples:
+ * - "John Doe" -> "JD"
+ * - "admin" -> "AD"
+ * - "A" -> "A"
+ */
+declare function getInitials(name: string): string;
+/**
+ * UserAvatar component that displays user initials in a circle.
+ * This is a pure presentational component - wrap it in UserMenu for dropdown functionality.
+ */
+declare function UserAvatar({ name, className }: UserAvatarProps): react_jsx_runtime.JSX.Element;
+
+interface UserMenuProps {
+    /** User's display name or username */
+    name: string;
+    /** Optional email to display in dropdown */
+    email?: string;
+    /** Callback when sign out is clicked */
+    onSignOut?: () => void;
+    /** Additional class names for the avatar trigger */
+    className?: string;
+}
+/**
+ * UserMenu component that displays a user avatar with a dropdown menu.
+ * Clicking the avatar opens a dropdown with user info and sign out option.
+ */
+declare function UserMenu({ name, email, onSignOut, className }: UserMenuProps): react_jsx_runtime.JSX.Element;
+
+type ModalViewRendererProps = {
+    view: View;
+    context: NubaseContextData;
+    params?: Record<string, any>;
+    resourceName?: string;
+    onClose?: () => void;
+    onRowClick?: (row: any) => void;
+    onError?: (error: Error) => void;
+};
+declare const ModalViewRenderer: FC<ModalViewRendererProps>;
+
+type ResourceCreateViewModalRendererProps = {
+    view: ResourceCreateView;
+    context: NubaseContextData;
+    resourceName?: string;
+    onClose?: () => void;
+    onCreate?: (data: ObjectOutput<any>) => void;
+    onError?: (error: Error) => void;
+};
+declare const ResourceCreateViewModalRenderer: FC<ResourceCreateViewModalRendererProps>;
+
+type ResourceSearchViewModalRendererProps = {
+    view: ResourceSearchView;
+    context: NubaseContextData;
+    params?: Record<string, any>;
+    resourceName?: string;
+    onClose?: () => void;
+    onRowClick?: (row: any) => void;
+    onError?: (error: Error) => void;
+};
+declare const ResourceSearchViewModalRenderer: FC<ResourceSearchViewModalRendererProps>;
+
+type ResourceViewViewModalRendererProps = {
+    view: ResourceViewView;
+    context: NubaseContextData;
+    params?: Record<string, any>;
+    onClose?: () => void;
+    onPatch?: (data: ObjectOutput<any>) => void;
+    onError?: (error: Error) => void;
+};
+declare const ResourceViewViewModalRenderer: FC<ResourceViewViewModalRendererProps>;
+
+type ResourceCreateViewRendererProps = {
+    view: ResourceCreateView;
+    resourceName?: string;
+    onCreate?: (data: ObjectOutput<any>) => void;
+    onError?: (error: Error) => void;
+};
+declare const ResourceCreateViewRenderer: FC<ResourceCreateViewRendererProps>;
+
+type ResourceSearchViewRendererProps = {
+    view: ResourceSearchView;
+    params?: Record<string, any>;
+    resourceName?: string;
+    resource?: ResourceDescriptor;
+    onError?: (error: Error) => void;
+};
+declare const ResourceSearchViewRenderer: FC<ResourceSearchViewRendererProps>;
+
+type ResourceViewViewRendererProps = {
+    view: ResourceViewView;
+    params?: Record<string, any>;
+    onPatch?: (data: ObjectOutput<any>) => void;
+    onError?: (error: Error) => void;
+};
+declare const ResourceViewViewRenderer: FC<ResourceViewViewRendererProps>;
+
+interface WidgetProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** The title of the widget */
+    title: string;
+    /** Optional icon component (not instantiated) shown before the title */
+    icon?: IconComponent;
+    /** Optional action elements (e.g., buttons) shown on the right side of the header */
+    action?: React$1.ReactNode;
+    /** Optional footer content */
+    footer?: React$1.ReactNode;
+    /** The widget content */
+    children: React$1.ReactNode;
+}
+/**
+ * Widget is a pre-composed Card component for dashboard-style content.
+ * It provides a compact header with title, optional icon, and action elements.
+ * Widget always includes a border separator between header and content.
+ * For layouts without the border, use the Card components directly.
+ */
+declare const Widget: React$1.ForwardRefExoticComponent<WidgetProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Dashboard builder that enables chained, type-safe dashboard configuration.
+ *
+ * The builder pattern enables sequential type inference, solving the circular
+ * dependency problem between API endpoints and widget configurations.
+ *
+ * @example
+ * ```typescript
+ * const analyticsDashboard = createDashboard("analytics")
+ *   .withApiEndpoints(apiEndpoints)
+ *   .withTitle("Analytics Dashboard")
+ *   .withWidgets([
+ *     {
+ *       type: "series",
+ *       id: "revenue-chart",
+ *       title: "Revenue Trend",
+ *       variant: "area",
+ *       endpoint: "getRevenueChart", // TypeScript validates this!
+ *       defaultLayout: { x: 0, y: 0, w: 8, h: 3 },
+ *     },
+ *     {
+ *       type: "kpi",
+ *       id: "total-revenue",
+ *       title: "Total Revenue",
+ *       endpoint: "getTotalRevenue", // TypeScript validates this!
+ *       defaultLayout: { x: 8, y: 0, w: 4, h: 2 },
+ *     },
+ *   ]);
+ * ```
+ */
+declare class DashboardBuilder<TId extends string, TApiEndpoints = never> {
+    private config;
+    constructor(id: TId);
+    /**
+     * Configure API endpoints for type-safe widget endpoint references.
+     * This must be called before withWidgets() to enable type checking.
+     */
+    withApiEndpoints<T>(apiEndpoints: T): DashboardBuilder<TId, T>;
+    /**
+     * Set the dashboard title.
+     */
+    withTitle(title: string): this;
+    /**
+     * Set the dashboard icon.
+     */
+    withIcon(icon: IconComponent): this;
+    /**
+     * Configure grid layout options.
+     */
+    withGridConfig(gridConfig: DashboardGridConfig): this;
+    /**
+     * Configure widgets for this dashboard.
+     * This is the final step that produces the DashboardDescriptor.
+     *
+     * TypeScript will validate that each widget's endpoint matches its expected data type:
+     * - Series widgets must reference endpoints returning SeriesData
+     * - Proportional widgets must reference endpoints returning ProportionalData
+     * - KPI widgets must reference endpoints returning KpiData
+     * - Table widgets must reference endpoints returning TableData
+     */
+    withWidgets(widgets: WidgetDescriptor<TApiEndpoints>[]): DashboardDescriptor<TApiEndpoints>;
+}
+/**
+ * Creates a new dashboard builder with the specified ID.
+ *
+ * The builder pattern enables sequential type inference:
+ * 1. First, call `.withApiEndpoints(apiEndpoints)` to provide the API type context
+ * 2. Then, configure the dashboard with `.withTitle()`, `.withGridConfig()`, etc.
+ * 3. Finally, call `.withWidgets([...])` to define the widgets with type-safe endpoint references
+ *
+ * @param id Unique identifier for the dashboard
+ * @returns A DashboardBuilder instance
+ *
+ * @example
+ * ```typescript
+ * import { apiEndpoints } from "schema";
+ *
+ * const salesDashboard = createDashboard("sales")
+ *   .withApiEndpoints(apiEndpoints)
+ *   .withTitle("Sales Dashboard")
+ *   .withGridConfig({ rowHeight: 100 })
+ *   .withWidgets([
+ *     {
+ *       type: "series",
+ *       id: "revenue",
+ *       title: "Revenue",
+ *       variant: "area",
+ *       endpoint: "getRevenueChart",
+ *       defaultLayout: { x: 0, y: 0, w: 8, h: 3 },
+ *     },
+ *   ]);
+ * ```
+ */
+declare function createDashboard<TId extends string>(id: TId): DashboardBuilder<TId, never>;
+
+/**
+ * Inline action definition for resource actions
+ */
+type InlineResourceActionConfig<TApiEndpoints> = {
+    label?: string;
+    icon?: React__default.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    disabled?: boolean;
+    variant?: "default" | "destructive";
+    onExecute: (args: {
+        selectedIds: (string | number)[];
+        context: NubaseContextData<TApiEndpoints>;
+    }) => void | Promise<void>;
+};
+/**
+ * Inline view definition for create views
+ */
+type InlineCreateViewConfig<TApiEndpoints, TActionIds extends string, TSchema extends ObjectSchema<any> = ObjectSchema<any>, TParamsSchema extends ObjectSchema<any> | undefined = undefined> = {
+    type: "resource-create";
+    id: string;
+    title: string;
+    schemaPost: (api: TApiEndpoints) => TSchema;
+    schemaParams?: (api: TApiEndpoints) => TParamsSchema;
+    actions?: ActionLayout<TActionIds>;
+    breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema>;
+    onSubmit: (args: {
+        data: Infer<TSchema>;
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<any>>;
+};
+/**
+ * Inline view definition for view views
+ */
+type InlineViewViewConfig<TApiEndpoints, TActionIds extends string, TSchema extends ObjectSchema<any> = ObjectSchema<any>, TParamsSchema extends ObjectSchema<any> | undefined = undefined> = {
+    type: "resource-view";
+    id: string;
+    title: string;
+    schemaGet: (api: TApiEndpoints) => TSchema;
+    schemaParams?: (api: TApiEndpoints) => TParamsSchema;
+    actions?: ActionLayout<TActionIds>;
+    breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema, Infer<TSchema>>;
+    onLoad: (args: {
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<Infer<TSchema>>>;
+    onPatch: (args: {
+        data: Partial<Infer<TSchema>>;
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<any>>;
+};
+/**
+ * Inline view definition for search views
+ */
+type InlineSearchViewConfig<TApiEndpoints, TActionIds extends string, TSchema extends ArraySchema<any> = ArraySchema<any>, TParamsSchema extends ObjectSchema<any> | undefined = undefined> = {
+    type: "resource-search";
+    id: string;
+    title: string;
+    schemaGet: (api: TApiEndpoints) => TSchema;
+    schemaParams?: (api: TApiEndpoints) => TParamsSchema;
+    tableActions?: ActionLayout<TActionIds>;
+    rowActions?: ActionLayout<TActionIds>;
+    breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema>;
+    onLoad: (args: {
+        context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<Infer<TSchema>>>;
+};
+/**
+ * Union type for all inline view configs
+ */
+type InlineViewConfig<TApiEndpoints, TActionIds extends string> = InlineCreateViewConfig<TApiEndpoints, TActionIds, any, any> | InlineViewViewConfig<TApiEndpoints, TActionIds, any, any> | InlineSearchViewConfig<TApiEndpoints, TActionIds, any, any>;
+/**
+ * Resource builder that enables chained, type-safe resource configuration.
+ *
+ * Usage:
+ * ```typescript
+ * createResource("ticket")
+ *   .withApiEndpoints(apiEndpoints)
+ *   .withActions({ delete: { ... } })
+ *   .withViews({ create: { ... }, view: { ... } })
+ * ```
+ */
+declare class ResourceBuilder<TId extends string, TApiEndpoints = never, TActions extends Record<string, InlineResourceActionConfig<TApiEndpoints>> = Record<string, never>> {
+    private config;
+    constructor(id: TId);
+    /**
+     * Configure API endpoints for this resource.
+     * This unlocks type-safe HTTP client in actions and views.
+     */
+    withApiEndpoints<T>(apiEndpoints: T): ResourceBuilder<TId, T, Record<string, never>>;
+    /**
+     * Configure actions for this resource.
+     * Actions can reference the API endpoints for type-safe HTTP calls.
+     */
+    withActions<T extends Record<string, InlineResourceActionConfig<TApiEndpoints>>>(actions: T): ResourceBuilder<TId, TApiEndpoints, T>;
+    /**
+     * Configure views for this resource.
+     * Views can reference API endpoints for schemas and action keys for tableActions/rowActions.
+     * This is the final step that produces the ResourceDescriptor.
+     */
+    withViews<TViews extends Record<string, InlineViewConfig<TApiEndpoints, keyof TActions & string>>>(views: TViews): ResourceDescriptor<{
+        [K in keyof TViews]: TViews[K] extends InlineViewConfig<TApiEndpoints, any> ? TViews[K] extends InlineCreateViewConfig<TApiEndpoints, any, infer TSchema, infer TParamsSchema> ? ResourceCreateView<TSchema, TApiEndpoints, TParamsSchema, keyof TActions & string> : TViews[K] extends InlineViewViewConfig<TApiEndpoints, any, infer TSchema, infer TParamsSchema> ? ResourceViewView<TSchema, TApiEndpoints, TParamsSchema, keyof TActions & string> : TViews[K] extends InlineSearchViewConfig<TApiEndpoints, any, infer TSchema, infer TParamsSchema> ? ResourceSearchView<TSchema, TApiEndpoints, TParamsSchema, keyof TActions & string> : never : never;
+    }, {
+        [K in keyof TActions]: TActions[K] extends InlineResourceActionConfig<TApiEndpoints> ? {
+            type: "resource";
+            id: string;
+            label?: string;
+            icon?: React__default.ComponentType<{
+                size?: number;
+                className?: string;
+            }>;
+            disabled?: boolean;
+            variant?: "default" | "destructive";
+            onExecute: (context: ResourceActionExecutionContext) => void | Promise<void>;
+        } : never;
+    }>;
+    private setApiEndpoints;
+    private setActions;
+}
+/**
+ * Creates a new resource builder with the specified ID.
+ *
+ * The builder pattern enables sequential type inference, solving the circular
+ * dependency problem between API endpoints, actions, and views.
+ *
+ * @example
+ * ```typescript
+ * const ticketResource = createResource("ticket")
+ *   .withApiEndpoints(apiEndpoints)
+ *   .withActions({
+ *     delete: {
+ *       label: "Delete",
+ *       onExecute: async ({ selectedIds, context }) => {
+ *         // context.http is fully typed
+ *       }
+ *     }
+ *   })
+ *   .withViews({
+ *     create: {
+ *       type: "resource-create",
+ *       schemaPost: (api) => api.postTicket.requestBody,
+ *       onSubmit: async ({ data, context }) => context.http.postTicket({ data })
+ *     }
+ *   });
+ * ```
+ */
+declare function createResource<TId extends string>(id: TId): ResourceBuilder<TId, never, Record<string, never>>;
+
+/**
+ * Factory function to create a ResourceCreateView with type inference.
+ * Eliminates redundancy by inferring schema and API client types from parameters.
+ */
+declare function createCreateView<TSchema extends ObjectSchema<any>, TEndpoints, TParamsSchema extends ObjectSchema<any> | undefined = undefined>({ id, title, schemaPost, schemaParams, onSubmit, }: {
+    id: string;
+    title: string;
+    schemaPost: TSchema;
+    schemaParams?: TParamsSchema;
+    onSubmit: ({ data, context, }: {
+        data: Infer<TSchema>;
+        context: NubaseContextData<TEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<any>>;
+}): ResourceCreateView<TSchema, TEndpoints, TParamsSchema>;
+/**
+ * Factory function to create a ResourceViewView with type inference.
+ * Eliminates redundancy by inferring schema and API client types from parameters.
+ */
+declare function createViewView<TSchema extends ObjectSchema<any>, TEndpoints, TParamsSchema extends ObjectSchema<any> | undefined = undefined>({ id, title, schemaGet, schemaParams, onLoad, onPatch, }: {
+    id: string;
+    title: string;
+    schemaGet: TSchema;
+    schemaParams?: TParamsSchema;
+    onLoad: ({ context, }: {
+        context: NubaseContextData<TEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<Infer<TSchema>>>;
+    onPatch: ({ data, context, }: {
+        data: Partial<Infer<TSchema>>;
+        context: NubaseContextData<TEndpoints, TParamsSchema>;
+    }) => Promise<HttpResponse<any>>;
+}): ResourceViewView<TSchema, TEndpoints, TParamsSchema>;
+
+/**
+ * Creates a view factory pre-configured with API endpoints.
+ * This eliminates the need to import apiEndpoints in each view file.
+ */
+declare function createViewFactory<TApiEndpoints>(apiEndpoints: TApiEndpoints): {
+    createView<TSchema extends ObjectSchema<any>, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string>(config: {
+        id: string;
+        title: string;
+        schemaGet: (api: TApiEndpoints) => TSchema;
+        schemaParams?: (api: TApiEndpoints) => TParamsSchema;
+        actions?: ActionLayout<TActionIds>;
+        breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema, Infer<TSchema>>;
+        onLoad: (args: {
+            context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+        }) => Promise<HttpResponse<Infer<TSchema>>>;
+        onPatch: (args: {
+            data: Partial<Infer<TSchema>>;
+            context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+        }) => Promise<HttpResponse<any>>;
+    }): ResourceViewView<TSchema, TApiEndpoints, TParamsSchema, TActionIds>;
+    createCreate<TSchema extends ObjectSchema<any>, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string>(config: {
+        id: string;
+        title: string;
+        schemaPost: (api: TApiEndpoints) => TSchema;
+        schemaParams?: (api: TApiEndpoints) => TParamsSchema;
+        actions?: ActionLayout<TActionIds>;
+        breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema>;
+        onSubmit: (args: {
+            data: Infer<TSchema>;
+            context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+        }) => Promise<HttpResponse<any>>;
+    }): ResourceCreateView<TSchema, TApiEndpoints, TParamsSchema, TActionIds>;
+    createSearch<TSchema extends ArraySchema<any>, TParamsSchema extends ObjectSchema<any> | undefined = undefined, TActionIds extends string = string>(config: {
+        id: string;
+        title: string;
+        schemaGet: (api: TApiEndpoints) => TSchema;
+        schemaParams?: (api: TApiEndpoints) => TParamsSchema;
+        tableActions?: ActionLayout<TActionIds>;
+        rowActions?: ActionLayout<TActionIds>;
+        breadcrumbs?: BreadcrumbDefinition<TApiEndpoints, TParamsSchema>;
+        onLoad: (args: {
+            context: NubaseContextData<TApiEndpoints, TParamsSchema>;
+        }) => Promise<HttpResponse<Infer<TSchema>>>;
+    }): ResourceSearchView<TSchema, TApiEndpoints, TParamsSchema, TActionIds>;
+};
+
+/**
+ * Helper to create a ResourceViewView with full type inference.
+ * Infers all generic types from the provided configuration.
+ */
+declare function defineViewView<TSchema extends ObjectSchema<any>, TParamsSchema extends ObjectSchema<any> | undefined, TConfig extends {
+    id: string;
+    title: string;
+    schema: TSchema;
+    schemaParams?: TParamsSchema;
+    onLoad: (args: {
+        context: any;
+    }) => Promise<HttpResponse<Infer<TSchema>>>;
+    onPatch: (args: {
+        data: Partial<Infer<TSchema>>;
+        context: any;
+    }) => Promise<HttpResponse<any>>;
+}>(config: TConfig): TConfig & {
+    type: "resource-view";
+};
+/**
+ * Helper to create a ResourceCreateView with full type inference.
+ * Infers all generic types from the provided configuration.
+ */
+declare function defineCreateView<TSchema extends ObjectSchema<any>, TParamsSchema extends ObjectSchema<any> | undefined, TConfig extends {
+    id: string;
+    title: string;
+    schema: TSchema;
+    schemaParams?: TParamsSchema;
+    onSubmit: (args: {
+        data: Infer<TSchema>;
+        context: any;
+    }) => Promise<HttpResponse<any>>;
+}>(config: TConfig): TConfig & {
+    type: "resource-create";
+};
+
+/**
+ * Workspace context for path-based multi-workspace.
+ * This file is intentionally separate from routes/root.tsx to avoid circular dependencies.
+ * Components can safely import from here without creating import cycles.
+ */
+interface WorkspaceContext {
+    slug: string;
+}
+/**
+ * Hook to get the current workspace context.
+ * Must be used within a route nested under /$workspace.
+ * @throws Error if used outside of workspace route
+ */
+declare function useWorkspace(): WorkspaceContext;
+/**
+ * Hook to optionally get the current workspace context.
+ * Returns null if not within a workspace route.
+ */
+declare function useWorkspaceOptional(): WorkspaceContext | null;
+/**
+ * Extract workspace slug from router state.
+ * Use this in commands and other non-React contexts where hooks aren't available.
+ */
+declare function getWorkspaceFromRouter(router: {
+    state: {
+        matches: Array<{
+            params: Record<string, string>;
+        }>;
+    };
+}): string | null;
+
+/**
+ * Keybinding extend options
+ */
+interface KeybindingExtendOptions {
+    /**
+     * Additional keybindings to add
+     */
+    add?: Keybinding[];
+    /**
+     * List of command IDs to remove from defaults
+     * More explicit and works better with action-based keybindings
+     */
+    removeCommands?: string[];
+}
+/**
+ * Creates an extended keybinding configuration from the defaults
+ * @param options Configuration for extending keybindings
+ * @returns Array of keybindings with extensions applied
+ */
+declare function extendKeybindings(options?: KeybindingExtendOptions): Keybinding[];
+/**
+ * Default keybindings object with extend functionality
+ */
+declare const defaultKeybindings: {
+    /**
+     * Get the default keybindings array
+     */
+    get(): Keybinding[];
+    /**
+     * Extend the default keybindings with additional or overridden bindings
+     * @param options Configuration for extending keybindings
+     * @returns Array of keybindings with extensions applied
+     *
+     * @example
+     * // Add a new action-based keybinding (recommended)
+     * const keybindings = defaultKeybindings.extend({
+     *   add: [{
+     *     key: "meta+/",
+     *     action: createCommandAction({ id: "theme-toggle" }, workbenchSetTheme)
+     *   }]
+     * });
+     *
+     * @example
+     * // Add a legacy command-based keybinding
+     * const keybindings = defaultKeybindings.extend({
+     *   add: [{ key: "meta+/", command: "workbench.setTheme", commandArgs: {} }]
+     * });
+     *
+     * @example
+     * // Remove default keybindings and add custom ones
+     * const keybindings = defaultKeybindings.extend({
+     *   removeCommands: ["workbench.runCommand"],
+     *   add: [{
+     *     key: "meta+shift+p",
+     *     action: createCommandAction({ id: "custom-cmd" }, myCustomCommand)
+     *   }]
+     * });
+     */
+    extend: typeof extendKeybindings;
+};
+
+/**
+ * Legacy parsed keybinding using string-based commands
+ */
+interface ParsedCommandKeybinding {
+    /** The original key string */
+    key: string;
+    /** Array of key sequences for chords (e.g., ["ctrl+k", "ctrl+c"]) */
+    sequences: string[];
+    /** The command to execute */
+    command: string;
+    /** Optional arguments for the command */
+    commandArgs?: Record<string, unknown>;
+}
+/**
+ * Modern parsed keybinding using typed actions
+ */
+interface ParsedActionKeybinding {
+    /** The original key string */
+    key: string;
+    /** Array of key sequences for chords (e.g., ["ctrl+k", "ctrl+c"]) */
+    sequences: string[];
+    /** The action to execute */
+    action: Action;
+}
+/**
+ * Union type supporting both legacy command and modern action keybindings
+ */
+type ParsedKeybinding = ParsedCommandKeybinding | ParsedActionKeybinding;
+interface KeySequence {
+    /** Modifier keys */
+    meta?: boolean;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    /** The main key */
+    key: string;
+}
+interface KeybindingState {
+    /** Current chord sequence being built */
+    currentChord: string[];
+    /** Timeout for chord completion */
+    chordTimeout: number | null;
+    /** Whether we're waiting for the next key in a chord */
+    waitingForChord: boolean;
+}
+
+/**
+ * Manages keybindings with VS Code-style syntax support including chords
+ */
+declare class KeybindingManager {
+    private keybindings;
+    private state;
+    private context;
+    private readonly CHORD_TIMEOUT;
+    /**
+     * Sets the Nubase context for action execution
+     */
+    setContext(context: NubaseContextData | null): void;
+    /**
+     * Registers an array of keybindings
+     */
+    registerKeybindings(keybindings: Keybinding[]): void;
+    /**
+     * Handles keyboard events and executes matching commands
+     */
+    handleKeyboardEvent(event: KeyboardEvent): Promise<boolean>;
+    /**
+     * Finds all keybindings that could match the current key
+     */
+    private findMatches;
+    /**
+     * Handles completion of a chord sequence
+     */
+    private handleChordCompletion;
+    /**
+     * Starts a new chord sequence
+     */
+    private startChordSequence;
+    /**
+     * Resets the chord timeout
+     */
+    private resetChordTimeout;
+    /**
+     * Resets the chord state
+     */
+    private resetChordState;
+    /**
+     * Executes a command or action for a matching keybinding
+     */
+    private executeKeybinding;
+    /**
+     * Determines if we should ignore a keyboard event based on the target element
+     */
+    private shouldIgnoreEvent;
+    /**
+     * Clears all registered keybindings
+     */
+    clear(): void;
+    /**
+     * Gets all registered keybindings
+     */
+    getKeybindings(): ParsedKeybinding[];
+}
+declare const keybindingManager: KeybindingManager;
+
+/**
+ * Parses a key string into a KeySequence
+ * Supports VS Code format: "ctrl+alt+k", "meta+shift+p", etc.
+ */
+declare function parseKeySequence(keyString: string): KeySequence;
+/**
+ * Parses a keybinding definition into ParsedKeybinding
+ * Supports chords like "ctrl+k ctrl+c" (space-separated sequences)
+ * Supports alternative keys as array: ["meta+k", "ctrl+k"]
+ * Supports both command-based and action-based keybindings
+ */
+declare function parseKeybinding(keybinding: Keybinding): ParsedKeybinding[];
+/**
+ * Creates a normalized key string from a KeyboardEvent
+ * Matches VS Code's key format
+ */
+declare function normalizeEventKey(event: KeyboardEvent): string;
+/**
+ * Checks if a key sequence matches a parsed sequence
+ */
+declare function matchesKeySequence(eventKey: string, targetSequence: string): boolean;
+
+/**
+ * Registers keybindings and sets up the global keyboard event listener
+ * This replaces the hook-based approach with a centralized system
+ */
+declare function registerKeybindings(keybindings: Keybinding[]): void;
+/**
+ * Cleans up the keybinding system
+ * Call this when unmounting the app or when you want to remove all keybindings
+ */
+declare function cleanupKeybindings(): void;
+/**
+ * Updates keybindings without removing the global listener
+ * Useful for hot-reloading keybinding configurations
+ */
+declare function updateKeybindings(keybindings: Keybinding[]): void;
+
+/**
+ * Resolved menu item with all display properties guaranteed.
+ * This is what components receive after resolution.
+ */
+interface ResolvedMenuItem {
+    id: string;
+    label: string;
+    subtitle?: string;
+    icon?: IconComponent;
+    disabled?: boolean;
+    variant?: "default" | "destructive";
+    /** String path or ResourceLink for type-safe resource navigation */
+    href?: string | ResourceLink;
+    commandId?: string;
+    commandArgs?: Record<string, unknown>;
+    onExecute?: () => void | Promise<void>;
+    onFocus?: () => void;
+    children?: ResolvedMenuItem[];
+}
+/**
+ * Resolves a MenuItem by deriving missing label/icon from command definitions.
+ *
+ * Resolution priority:
+ * 1. Explicit `label`/`icon` on the MenuItem (highest priority)
+ * 2. `name`/`icon` from the referenced command definition
+ * 3. `id` as fallback for label (lowest priority)
+ *
+ * @param item - The menu item to resolve
+ * @param commandRegistry - Command registry to look up command definitions
+ * @returns Resolved menu item with guaranteed label
+ */
+declare function resolveMenuItem(item: MenuItem, commandRegistry?: CommandRegistry): ResolvedMenuItem;
+/**
+ * Resolves an array of menu items.
+ */
+declare function resolveMenuItems(items: MenuItem[], commandRegistry?: CommandRegistry): ResolvedMenuItem[];
+
+interface ParseErrorDetail {
+    path: string;
+    message: string;
+    code: string;
+    expected?: string;
+    received?: string;
+}
+interface NetworkErrorOptions {
+    endpoint: string;
+    method: string;
+    statusCode?: number;
+    responseText?: string;
+}
+/**
+ * Base class for all network-related errors
+ */
+declare abstract class NetworkError extends Error {
+    readonly endpoint: string;
+    readonly method: string;
+    readonly timestamp: Date;
+    constructor(message: string, options: NetworkErrorOptions);
+}
+/**
+ * Error thrown when client-side validation fails before making a network request
+ */
+declare class ClientNetworkError extends NetworkError {
+    get [Symbol.toStringTag](): string;
+    readonly phase: "request-validation" | "response-validation" | "network-failure";
+    readonly parseErrors?: ParseErrorDetail[];
+    readonly originalError?: unknown;
+    readonly zodError?: ZodError;
+    constructor(message: string, options: NetworkErrorOptions & {
+        phase: "request-validation" | "response-validation" | "network-failure";
+        parseErrors?: ParseErrorDetail[];
+        originalError?: unknown;
+        zodError?: ZodError;
+    });
+    toString(): string;
+    toJSON(): any;
+    /**
+     * Creates a ClientNetworkError for network failures (no response from server)
+     */
+    static fromNetworkFailure(error: unknown, options: NetworkErrorOptions): ClientNetworkError;
+}
+/**
+ * Error thrown when the server returns an error response
+ */
+declare class ServerNetworkError extends NetworkError {
+    get [Symbol.toStringTag](): string;
+    readonly statusCode: number;
+    readonly responseText?: string;
+    readonly responseData?: unknown;
+    constructor(message: string, options: NetworkErrorOptions & {
+        statusCode: number;
+        responseText?: string;
+        responseData?: unknown;
+    });
+    toString(): string;
+    toJSON(): any;
+    /**
+     * Creates a ServerNetworkError from an HTTP response
+     */
+    static fromResponse(response: Response, responseText?: string, responseData?: unknown): ServerNetworkError;
+    /**
+     * Checks if this is a specific type of server error
+     */
+    isNotFound(): boolean;
+    isUnauthorized(): boolean;
+    isForbidden(): boolean;
+    isServerError(): boolean;
+    isClientError(): boolean;
+}
+/**
+ * Type guard to check if an error is a NetworkError
+ */
+declare function isNetworkError(error: unknown): error is NetworkError;
+/**
+ * Type guard to check if an error is a ClientNetworkError
+ */
+declare function isClientNetworkError(error: unknown): error is ClientNetworkError;
+/**
+ * Type guard to check if an error is a ServerNetworkError
+ */
+declare function isServerNetworkError(error: unknown): error is ServerNetworkError;
+/**
+ * Helper to get a user-friendly error message
+ */
+declare function getNetworkErrorMessage(error: unknown): string;
+
+export { ACTION_COLUMN_KEY, type Action, ActionBar, ActionBarContainer, type ActionBarContainerProps, type ActionBarProps, ActionCellFormatter, ActionCellRendererCell, ActionCellRendererGroup, ActionDropdownMenu, type ActionDropdownMenuProps, type ActionKeybinding, type ActionLayout, type ActionOrSeparator, ActivityIndicator, type ActivityIndicatorProps, type AuthenticatedUser, type AuthenticationController, type AuthenticationState, type AuthenticationStateListener, type BaseAction, type BaseModalFrameProps, type BaseWidgetDescriptor, Breadcrumb, BreadcrumbBar, type BreadcrumbBarProps, BreadcrumbEllipsis, type BreadcrumbEllipsisProps, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, type BreadcrumbListProps, BreadcrumbPage, type BreadcrumbPageProps, type BreadcrumbProps, BreadcrumbSeparator, type BreadcrumbSeparatorProps, Button, ButtonBar, type ButtonBarProps, type ButtonProps, type CalculatedColumn, type CalculatedColumnOrColumnGroup, type CalculatedColumnParent, Callout, type CalloutProps, Card, CardAction, type CardActionProps, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, CellComponent as Cell, type CellCopyArgs, type CellKeyDownArgs, type CellKeyboardEvent, type CellMouseArgs, type CellMouseEvent, type CellPasteArgs, type CellRendererProps, type CellSelectArgs, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, type CheckboxProps, ClientNetworkError, type ColSpanArgs, type Column, type ColumnGroup, type ColumnOrColumnGroup, type ColumnWidth, type ColumnWidths, type CommandAction, type CommandRegistry, ConnectedWidget, type ConnectedWidgetProps, ControllableSearchableTree, type ControllableSearchableTreeProps, Dashboard, type DashboardDescriptor, type DashboardDragConfig, type DashboardGridConfig, type DashboardProps, DashboardRenderer, type DashboardRendererProps, type DashboardResizeConfig, DashboardWidget, type DashboardWidgetProps, DataGrid, DataGridDefaultRenderersContext, type DataGridHandle, type DataGridProps, DataState, type DataStateProps, type DefaultColumnOptions, Dialog, type DialogProps, Dock, type DockProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EnhancedPagination, type EnhancedPaginationProps, type ErrorListener, type FillEvent, type FlatItem, type FlatMenuItem, FormControl, type FormControlProps, FormFieldRenderer, type FormFieldRendererProps, FormValidationErrors, type FormValidationErrorsProps, type GlobalActionsConfig, type HandlerAction, HttpClient, type HttpRequestConfig, type HttpResponse, type IconComponent, type InlineCreateViewConfig, type InlineResourceActionConfig, type InlineSearchViewConfig, type InlineViewConfig, type InlineViewViewConfig, type KeySequence, type Keybinding, type KeybindingState, type KpiWidgetDescriptor, Label, type LabelProps, EnhancedPagination as LegacyPagination, ListNavigator, type ListNavigatorItem, type ListNavigatorProps, type LoginCompleteCredentials, type LoginCredentials, type LoginStartResponse, MainNav, type MainNavProps, type MarkdownCommand, MarkdownTextArea, type MarkdownTextAreaHandle, type MarkdownTextAreaProps, type MenuItem, MenuItemComponent, type MenuItemOrSeparator, Modal, type ModalAlignment, type ModalConfig, ModalFrame, type ModalFrameProps, ModalFrameSchemaForm, type ModalFrameSchemaFormProps, ModalFrameStructured, type ModalFrameStructuredProps, type ModalInstance, type ModalProps, ModalProvider, type ModalSize, ModalViewRenderer, type ModalViewRendererProps, type NavItem, NavItems, NetworkError, type NetworkErrorOptions, NubaseApp, type NubaseAppProps, type NubaseContextData, type NubaseFrontendConfig, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, type EnhancedPaginationProps as PaginationProps, type ParseErrorDetail, type ParsedKeybinding, type PromiseResult, type PromiseToastCallback, type PromiseToastConfig, type PromiseToastOptions, type ProportionalChartVariant, type ProportionalWidgetDescriptor, type RenderCellProps, type RenderCheckboxProps, type RenderEditCellProps, type RenderGroupCellProps, type RenderHeaderCellProps, type RenderRowProps, type RenderSortIconProps, type RenderSortPriorityProps, type RenderSortStatusProps, type RenderSummaryCellProps, type Renderers, type ResolvedMenuItem, type ResourceAction, type ResourceActionExecutionContext, type ResourceCreateView, ResourceCreateViewModalRenderer, type ResourceCreateViewModalRendererProps, ResourceCreateViewRenderer, type ResourceCreateViewRendererProps, type ResourceDescriptor, type ResourceLink, type ResourceSearchView, ResourceSearchViewModalRenderer, type ResourceSearchViewModalRendererProps, ResourceSearchViewRenderer, type ResourceSearchViewRendererProps, type ResourceViewView, ResourceViewViewModalRenderer, type ResourceViewViewModalRendererProps, ResourceViewViewRenderer, type ResourceViewViewRendererProps, RowComponent as Row, type RowHeightArgs, type RowsChangeData, SELECT_COLUMN_KEY, SchemaForm, SchemaFormBody, type SchemaFormBodyProps, SchemaFormButtonBar, type SchemaFormButtonBarProps, type SchemaFormConfiguration, type SchemaFormProps, SchemaFormValidationErrors, type SchemaFormValidationErrorsProps, SearchBar, type SearchBarProps, SearchTextInput, type SearchTextInputProps, SearchableTreeNavigator, type SearchableTreeNavigatorProps, Select, SelectCellFormatter, type SelectCellOptions, SelectColumn, type SelectHeaderRowEvent, type SelectOption, type SelectProps, type SelectRowEvent, type SelectionRange, type SeriesChartVariant, type SeriesWidgetDescriptor, ServerNetworkError, type SignupCredentials, type SortColumn, type SortDirection, type StandardViews, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, type TableWidgetDescriptor, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, type TextController, TextInput, type TextInputProps, type TextState, ThemeToggle, type ThemeToggleProps, Toast, ToastContainer, type ToastData, type ToastOptions, type ToastPosition, ToastProvider, type ToastType, ToggleGroup, TopBar, type TopBarProps, TreeDataGrid, type TreeDataGridProps, TreeNavigator, type TreeNavigatorItem, type TreeNavigatorProps, TypedApiClient, type TypedApiClientFromEndpoints, type TypedCommandDefinition, type UseDialogResult, type UseModalResult, type UseNubaseMutationOptions, type UseNubaseQueryOptions, type UseSchemaFormOptions, UserAvatar, type UserAvatarProps, UserMenu, type UserMenuProps, type View, type ViewBase, type ViewType, Widget, type WidgetDescriptor, type WidgetLayoutConfig, type WidgetProps, type WorkspaceContext, type WorkspaceInfo, boldCommand, checkListCommand, cleanupKeybindings, codeBlockCommand, codeCommand, commandRegistry, index as commands, createActionColumn, createCommand, createCommandAction, createCreateView, createDashboard, createHandlerAction, createResource, createResourceAction, createTypedApiClient, createViewFactory, createViewView, defaultKeybindings, defineCreateView, defineViewView, filterNavItems, flattenNavItems, getInitials, getLayout, getNetworkErrorMessage, getResourceLinkSearch, getWorkspaceFromRouter, groupActionsBySeparators, headingCommand, imageCommand, isClientNetworkError, isCommandAction, isHandlerAction, isNetworkError, isResourceLink, isServerNetworkError, italicCommand, keybindingManager, linkCommand, matchesKeySequence, normalizeEventKey, orderedListCommand, parseKeySequence, parseKeybinding, quoteCommand, registerKeybindings, renderCheckbox, renderHeaderCell, renderSortIcon, renderSortPriority, renderToggleGroup, renderValue, resolveMenuItem, resolveMenuItems, resolveResourceLink, resourceLink, showPromiseToast, showToast, strikethroughCommand, textEditor, unorderedListCommand, updateKeybindings, useActionExecutor, useChart, useComputedMetadata, useDialog, useHeaderRowSelection, useLayout, useModal, useNubaseMutation, useNubaseQuery, useResourceCreateMutation, useResourceDeleteMutation, useResourceInvalidation, useResourceSearchQuery, useResourceUpdateMutation, useResourceViewQuery, useRowSelection, useSchemaForm, useToast, useWorkspace, useWorkspaceOptional, workbenchOpenResourceOperation, workbenchOpenResourceOperationInModal, workbenchRunCommand, workbenchSetTheme, workbenchViewHistory };