import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
import { AppConfigInterface } from '@loopstack/contracts/api';
import { AuthResource } from '../../packages/client';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { ClassProp } from 'class-variance-authority/types';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { Component } from 'react';
import { ComponentType } from 'react';
import { Context } from 'react';
import { default as default_2 } from 'react';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { DocumentItemInterface } from '@loopstack/contracts/types';
import { Drawer as Drawer_2 } from 'vaul';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import { EnvironmentConfigInterface } from '@loopstack/contracts/api';
import { ErrorInfo } from 'react';
import { ExternalToast } from 'sonner';
import { JSONSchemaDefinition } from '@loopstack/contracts/schemas';
import { JSX } from 'react/jsx-runtime';
import * as LabelPrimitive from '@radix-ui/react-label';
import { PaginatedInterface } from '@loopstack/contracts/api';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as React_2 from 'react';
import { ReactElement } from 'react';
import { ReactNode } from 'react';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import * as SliderPrimitive from '@radix-ui/react-slider';
import { StudioDocumentConfig } from '@loopstack/contracts/api';
import * as SwitchPrimitive from '@radix-ui/react-switch';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { useAppsConfig } from '@loopstack/react';
import { useAvailableEnvironments } from '@loopstack/react';
import { useBatchDeleteWorkspaces } from '@loopstack/react';
import { useCreateWorkflow } from '@loopstack/react';
import { useCreateWorkspace } from '@loopstack/react';
import { useDeleteWorkflow } from '@loopstack/react';
import { useDeleteWorkspace } from '@loopstack/react';
import { UseMutationResult } from '@tanstack/react-query';
import { useNavigate } from 'react-router-dom';
import { UseQueryResult } from '@tanstack/react-query';
import { useSetFavouriteWorkspace } from '@loopstack/react';
import { useUpdateWorkflow } from '@loopstack/react';
import { useUpdateWorkspace } from '@loopstack/react';
import { useWorkflow } from '@loopstack/react';
import { useWorkflowCheckpoints } from '@loopstack/react';
import { useWorkflowSource } from '@loopstack/react';
import { useWorkflowStatus } from '@loopstack/react';
import { useWorkspace } from '@loopstack/react';
import { VariantProps } from 'class-variance-authority';
import { WorkflowFullInterface } from '@loopstack/contracts/api';
import { WorkflowState } from '@loopstack/contracts/enums';
import { WorkspaceEnvironmentInterface } from '@loopstack/contracts/api';
import { WorkspaceInterface } from '@loopstack/contracts/api';

export declare function Accordion({ ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Root>): JSX.Element;

export declare function AccordionContent({ className, children, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Content>): JSX.Element;

export declare function AccordionItem({ className, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Item>): JSX.Element;

export declare function AccordionTrigger({ className, children, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Trigger>): JSX.Element;

export declare function Alert({ className, variant, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof alertVariants>): JSX.Element;

export declare function AlertDescription({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function AlertDialog({ ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Root>): JSX.Element;

export declare function AlertDialogAction({ className, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Action>): JSX.Element;

export declare function AlertDialogCancel({ className, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Cancel>): JSX.Element;

export declare function AlertDialogContent({ className, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Content>): JSX.Element;

export declare function AlertDialogDescription({ className, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Description>): JSX.Element;

export declare function AlertDialogFooter({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function AlertDialogHeader({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function AlertDialogOverlay({ className, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Overlay>): JSX.Element;

export declare function AlertDialogPortal({ ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Portal>): JSX.Element;

export declare function AlertDialogTitle({ className, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Title>): JSX.Element;

export declare function AlertDialogTrigger({ ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Trigger>): JSX.Element;

export declare function AlertTitle({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

declare const alertVariants: (props?: ({
    variant?: "default" | "destructive" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Avatar({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Root>): JSX.Element;

export declare function AvatarFallback({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Fallback>): JSX.Element;

export declare function AvatarImage({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Image>): JSX.Element;

export declare function Badge({ className, variant, asChild, ...props }: React_2.ComponentProps<'span'> & VariantProps<typeof badgeVariants> & {
    asChild?: boolean;
}): JSX.Element;

export declare const badgeVariants: (props?: ({
    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
} & ClassProp) | undefined) => string;

declare interface BaseSnackbarProps {
    message?: string | null;
    variant?: ToastVariant;
    show?: boolean;
    icon?: default_2.ReactNode;
    duration?: number;
    position?: ExternalToast['position'];
    id?: string | number;
    onDismiss?: () => void;
}

declare interface BasicErrorComponentProps {
    error?: string | null;
}

export declare interface BatchAction {
    id: string;
    label: string;
    icon?: React.ReactNode;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
    action: (selectedIds: string[]) => Promise<void> | void;
}

declare interface BatchAction_2 {
    id: string;
    label: string;
    icon?: React.ReactNode;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
    action: (selectedIds: string[]) => Promise<void> | void;
}

export declare function Breadcrumb({ ...props }: React_2.ComponentProps<'nav'>): JSX.Element;

export declare function BreadcrumbEllipsis({ className, ...props }: React_2.ComponentProps<'span'>): JSX.Element;

export declare function BreadcrumbItem({ className, ...props }: React_2.ComponentProps<'li'>): JSX.Element;

export declare function BreadcrumbLink({ asChild, className, ...props }: React_2.ComponentProps<'a'> & {
    asChild?: boolean;
}): JSX.Element;

export declare function BreadcrumbList({ className, ...props }: React_2.ComponentProps<'ol'>): JSX.Element;

export declare function BreadcrumbPage({ className, ...props }: React_2.ComponentProps<'span'>): JSX.Element;

export declare interface BreadCrumbsData {
    label: string;
    href?: string;
    icon?: React.ReactNode;
    current?: boolean;
}

export declare function BreadcrumbSeparator({ children, className, ...props }: React_2.ComponentProps<'li'>): JSX.Element;

export declare function Button({ className, variant, size, asChild, ...props }: React_2.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
    asChild?: boolean;
}): JSX.Element;

export declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
    size?: "icon" | "default" | "sm" | "lg" | "icon-sm" | "icon-lg" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Card({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function CardAction({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function CardContent({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function CardDescription({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function CardFooter({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function CardHeader({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function CardTitle({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function Checkbox({ className, ...props }: React_2.ComponentProps<typeof CheckboxPrimitive.Root>): JSX.Element;

export declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): JSX.Element;

export declare function CollapsibleContent({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): JSX.Element;

export declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): JSX.Element;

export declare interface Column {
    id: string;
    label: string;
    minWidth?: number;
    align?: 'right' | 'left' | 'center';
    format?: (value: unknown, row?: unknown) => default_2.ReactNode;
}

export declare const CompletionMessagePaper: default_2.FC<CompletionMessagePaperProps>;

declare interface CompletionMessagePaperProps {
    role?: 'system' | 'user' | 'assistant' | 'tool' | 'error' | 'document';
    children: default_2.ReactNode;
    timestamp?: Date;
    metadata?: Record<string, any>;
    fullWidth?: boolean;
    className?: string;
}

export declare interface ComponentOverrides {
    CreateWorkspace?: ComponentType<CreateWorkspaceProps>;
    EditWorkspace?: ComponentType<EditWorkspaceProps>;
    SidebarHeader?: ComponentType;
    SidebarFooter?: ComponentType;
}

export declare const ComponentOverridesProvider: ({ children, overrides, }: {
    children: ReactNode;
    overrides: ComponentOverrides;
}) => JSX.Element;

export declare const ConfirmDialog: React.FC<ConfirmDialogProps>;

declare interface ConfirmDialogProps {
    isOpen: boolean;
    onOpenChange: (open: boolean) => void;
    title: string;
    description: string;
    onConfirm: () => void;
    confirmText?: string;
    cancelText?: string;
    variant?: 'default' | 'destructive';
}

/** Auth surface of an environment, for hosts that probe/login before mounting Studio. */
export declare function createApiClient(environment: Environment): {
    auth: AuthResource;
};

export declare const CreateWorkspace: ({ types, workspace, onSuccess }: CreateWorkspaceProps) => JSX.Element;

export declare interface CreateWorkspaceProps {
    types: AppConfigInterface[];
    workspace?: WorkspaceInterface;
    onSuccess: (workspace?: WorkspaceInterface) => void;
}

export declare const CustomItemListView: <T extends Item_2>({ loading, error, items, totalItems, filterConfig, onClick, handleNew, setPage, setRowsPerPage, setSearchTerm, setFilters, searchTerm, filters, page, rowsPerPage, batchActions, batchDelete, enableBatchActions, rowActions, itemRenderer, newButtonLabel, }: ListViewProps_2<T>) => JSX.Element;

export declare function DashboardPage(): JSX.Element;

export declare function DataList<T extends {
    id: string;
}>({ data, totalItems, loading, error, page, pageSize, onPageChange, onPageSizeChange, searchTerm, onSearchChange, filters, filterConfig, onFiltersChange, onRowClick, onNew, enableBatchActions, batchActions, onBatchDelete, rowActions, itemRenderer, newButtonLabel, }: DataListProps<T>): JSX.Element;

export declare interface DataListProps<T = any> {
    title?: string;
    data: T[];
    totalItems: number;
    loading?: boolean;
    error?: Error | null;
    page: number;
    pageSize: number;
    onPageChange: (page: number) => void;
    onPageSizeChange: (size: number) => void;
    searchTerm?: string;
    onSearchChange?: (term: string) => void;
    filters?: Record<string, string>;
    filterConfig?: Record<string, FilterOption[]>;
    onFiltersChange?: (filters: Record<string, string>) => void;
    onRowClick?: (item: T) => void;
    onEdit?: (item: T) => void;
    onDelete?: (id: string) => void;
    onNew?: () => void;
    rowActions?: RowAction_2<T>[];
    enableBatchActions?: boolean;
    batchActions?: BatchAction_2[];
    onBatchDelete?: (ids: string[]) => Promise<void> | void;
    itemRenderer?: (item: T) => ReactElement;
    newButtonLabel?: string;
}

export declare function DataTable<T extends {
    id: string;
}>({ data, columns, totalItems, loading, error, page, pageSize, onPageChange, onPageSizeChange, sortBy, sortOrder, onSortChange, searchTerm, onSearchChange, filters, filterConfig, onFiltersChange, onRowClick, onEdit, onDelete, onNew, newButtonLabel, enableBatchActions, batchActions, onBatchDelete, rowActions, deleteConfirmTitle, deleteConfirmDescription, }: DataTableProps<T>): JSX.Element;

export declare const DataTableBatchActions: React.FC<DataTableBatchActionsProps>;

declare interface DataTableBatchActionsProps {
    selectedCount: number;
    batchActions: BatchAction[];
    onBatchAction: (action: BatchAction) => void;
}

export declare interface DataTableColumn<T = any> {
    id: string;
    label: string;
    minWidth?: number;
    align?: 'left' | 'center' | 'right';
    sortable?: boolean;
    format?: (value: any, row: T) => React.ReactNode;
}

export declare const DataTableFilters: React.FC<DataTableFiltersProps>;

declare interface DataTableFiltersProps {
    filters: Record<string, string>;
    filterConfig: Record<string, FilterOption[]>;
    onFiltersChange?: (filters: Record<string, string>) => void;
    isOpen: boolean;
}

export declare const DataTablePagination: React.FC<DataTablePaginationProps>;

declare interface DataTablePaginationProps {
    page: number;
    pageSize: number;
    totalItems: number;
    onPageChange: (page: number) => void;
    onPageSizeChange: (size: number) => void;
}

export declare interface DataTableProps<T = any> {
    title?: string;
    data: T[];
    columns: DataTableColumn<T>[];
    totalItems: number;
    loading?: boolean;
    error?: Error | null;
    page: number;
    pageSize: number;
    onPageChange: (page: number) => void;
    onPageSizeChange: (size: number) => void;
    sortBy?: string;
    sortOrder?: 'ASC' | 'DESC';
    onSortChange: (field: string, order: 'ASC' | 'DESC') => void;
    searchTerm?: string;
    onSearchChange: (term: string) => void;
    filters?: Record<string, string>;
    filterConfig?: Record<string, FilterOption[]>;
    onFiltersChange: (filters: Record<string, string>) => void;
    onRowClick?: (item: T) => void;
    onEdit?: (item: T) => void;
    onDelete?: (id: string) => void;
    onNew?: () => void;
    newButtonLabel?: string;
    deleteConfirmTitle?: (itemId: string) => string;
    deleteConfirmDescription?: (itemId: string) => string;
    rowActions?: RowAction<T>[];
    enableBatchActions?: boolean;
    batchActions?: BatchAction[];
    onBatchDelete?: (ids: string[]) => Promise<void> | void;
}

export declare const DataTableToolbar: React.FC<DataTableToolbarProps>;

declare interface DataTableToolbarProps {
    searchTerm?: string;
    onSearchChange?: (term: string) => void;
    onFilterToggle: () => void;
    onNew?: () => void;
    filterCount: number;
    isFilterOpen: boolean;
    newButtonLabel?: string;
    children?: any;
    showFilter: boolean;
    showSearch: boolean;
}

export declare const DebugPage: () => JSX.Element;

export declare function DebugWorkflowDetailsPage(): JSX.Element;

export declare function DebugWorkflowsPage(): JSX.Element;

export declare function Dialog({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Root>): JSX.Element;

export declare function DialogClose({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Close>): JSX.Element;

export declare function DialogContent({ className, children, showCloseButton, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Content> & {
    showCloseButton?: boolean;
}): JSX.Element;

export declare function DialogDescription({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Description>): JSX.Element;

export declare function DialogFooter({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function DialogHeader({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function DialogOverlay({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Overlay>): JSX.Element;

export declare function DialogPortal({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Portal>): JSX.Element;

export declare function DialogTitle({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Title>): JSX.Element;

export declare function DialogTrigger({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Trigger>): JSX.Element;

export declare const DiscordLogo: default_2.FC<DiscordLogoProps>;

declare interface DiscordLogoProps {
    className?: string;
}

declare interface DocumentRendererProps {
    parentWorkflow: WorkflowFullInterface;
    workflow: WorkflowFullInterface;
    document: DocumentItemInterface;
    isActive: boolean;
    isLastItem: boolean;
}

export declare function Drawer({ ...props }: React_2.ComponentProps<typeof Drawer_2.Root>): JSX.Element;

export declare function DrawerClose({ ...props }: React_2.ComponentProps<typeof Drawer_2.Close>): JSX.Element;

export declare function DrawerContent({ className, children, ...props }: React_2.ComponentProps<typeof Drawer_2.Content>): JSX.Element;

export declare function DrawerDescription({ className, ...props }: React_2.ComponentProps<typeof Drawer_2.Description>): JSX.Element;

export declare function DrawerFooter({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function DrawerHeader({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function DrawerOverlay({ className, ...props }: React_2.ComponentProps<typeof Drawer_2.Overlay>): JSX.Element;

export declare function DrawerPortal({ ...props }: React_2.ComponentProps<typeof Drawer_2.Portal>): JSX.Element;

export declare function DrawerTitle({ className, ...props }: React_2.ComponentProps<typeof Drawer_2.Title>): JSX.Element;

export declare function DrawerTrigger({ ...props }: React_2.ComponentProps<typeof Drawer_2.Trigger>): JSX.Element;

export declare function DropdownMenu({ ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Root>): JSX.Element;

export declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): JSX.Element;

export declare function DropdownMenuContent({ className, sideOffset, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Content>): JSX.Element;

export declare function DropdownMenuGroup({ ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Group>): JSX.Element;

export declare function DropdownMenuItem({ className, inset, variant, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
    inset?: boolean;
    variant?: 'default' | 'destructive';
}): JSX.Element;

export declare function DropdownMenuLabel({ className, inset, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
    inset?: boolean;
}): JSX.Element;

export declare function DropdownMenuPortal({ ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Portal>): JSX.Element;

export declare function DropdownMenuRadioGroup({ ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): JSX.Element;

export declare function DropdownMenuRadioItem({ className, children, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): JSX.Element;

export declare function DropdownMenuSeparator({ className, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Separator>): JSX.Element;

export declare function DropdownMenuShortcut({ className, ...props }: React_2.ComponentProps<'span'>): JSX.Element;

export declare function DropdownMenuSub({ ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Sub>): JSX.Element;

export declare function DropdownMenuSubContent({ className, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): JSX.Element;

export declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
    inset?: boolean;
}): JSX.Element;

export declare function DropdownMenuTrigger({ ...props }: React_2.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): JSX.Element;

export declare interface EditWorkspaceProps {
    types: AppConfigInterface[];
    workspace: WorkspaceInterface;
    onSuccess: (workspace?: WorkspaceInterface) => void;
}

export declare function EmbedWorkbenchPage(): JSX.Element;

export declare interface Environment {
    id: string;
    name: string;
    url: string;
    getIdToken?: () => Promise<string>;
}

export declare function EnvironmentEmbedRoot(): JSX.Element;

export declare interface EnvironmentOption {
    id: string;
    type: string;
    name: string;
    local?: boolean;
}

export declare function EnvironmentSlotSelector({ slot, environments, selectedEnvironmentId, onSelect, onCreateEnvironment, isCreating, error, }: EnvironmentSlotSelectorProps): JSX.Element;

declare interface EnvironmentSlotSelectorProps {
    slot: EnvironmentConfigInterface;
    environments: EnvironmentOption[];
    selectedEnvironmentId: string | undefined;
    onSelect: (environmentId: string) => void;
    onCreateEnvironment?: () => void;
    isCreating?: boolean;
    error?: string;
}

export declare const ErrorAlert: default_2.FC<BasicErrorComponentProps>;

export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
    state: ErrorBoundaryState;
    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
    handleRetry: () => void;
    render(): ReactNode;
}

declare interface ErrorBoundaryProps {
    children: ReactNode;
    fallback?: ReactNode;
    onRetry?: () => void;
}

declare interface ErrorBoundaryState {
    hasError: boolean;
    error: Error | null;
}

export declare const ErrorSnackbar: default_2.FC<ErrorSnackbarProps>;

declare interface ErrorSnackbarProps {
    error: Error | string | null | undefined;
}

export declare function FeatureRegistryProvider({ appName, children }: FeatureRegistryProviderProps): JSX.Element;

export declare interface FeatureRegistryProviderProps {
    /** App name to scope features to. Must match an `appName` from `/api/v1/config/apps`. */
    appName: string;
    children: ReactNode;
}

export declare type FilterOption = string | {
    label: string;
    value: string;
};

export declare const GoogleLogo: default_2.FC<GoogleLogoProps>;

declare interface GoogleLogoProps {
    className?: string;
}

export declare function Input({ className, type, ...props }: React_2.ComponentProps<'input'>): JSX.Element;

declare interface Item {
    id: string;
}

declare interface Item_2 {
    id: string;
}

export declare const ItemListView: <T extends Item>({ loading, error, items, totalItems, columns, filterConfig, deleteItem, onClick, handleNew, handleEdit, setPage, setRowsPerPage, setOrderBy, setOrder, setSearchTerm, setFilters, orderBy, order, searchTerm, filters, page, rowsPerPage, batchActions, batchDelete, enableBatchActions, rowActions, deleteConfirmTitle, deleteConfirmDescription, newButtonLabel, }: ListViewProps<T>) => JSX.Element;

export declare function Label({ className, ...props }: React_2.ComponentProps<typeof LabelPrimitive.Root>): JSX.Element;

declare interface ListViewProps<T extends Item = Item> {
    loading: boolean;
    error: Error | null;
    items: T[];
    totalItems: number;
    columns: Column[];
    filterConfig: Record<string, FilterOption[]>;
    deleteItem?: (id: string) => void;
    onClick?: (id: string) => void;
    handleNew?: () => void;
    handleEdit?: (item: T) => void;
    setPage: (page: number) => void;
    setRowsPerPage: (rows: number) => void;
    setOrderBy: (field: string) => void;
    setOrder: (order: 'ASC' | 'DESC') => void;
    setSearchTerm: (search: string) => void;
    setFilters: (filters: Record<string, string>) => void;
    orderBy: string;
    order: 'ASC' | 'DESC';
    searchTerm: string | undefined;
    filters: Record<string, string>;
    page: number;
    rowsPerPage: number;
    batchActions?: OriginalBatchAction[];
    batchDelete?: (ids: string[]) => void | Promise<void>;
    enableBatchActions?: boolean;
    rowActions?: OriginalRowAction<T>[];
    deleteConfirmTitle?: (itemId: string) => string;
    deleteConfirmDescription?: (itemId: string) => string;
    newButtonLabel?: string;
}

declare interface ListViewProps_2<T extends Item_2 = Item_2> {
    loading: boolean;
    error: Error | null;
    items: T[];
    totalItems: number;
    filterConfig?: Record<string, string[]>;
    onClick: (id: string) => void;
    handleNew: () => void;
    setPage: (page: number) => void;
    setRowsPerPage: (rows: number) => void;
    setSearchTerm?: (search: string) => void;
    setFilters?: (filters: Record<string, string>) => void;
    searchTerm?: string | undefined;
    filters?: Record<string, string>;
    page: number;
    rowsPerPage: number;
    batchActions?: OriginalBatchAction_2[];
    batchDelete?: (ids: string[]) => void | Promise<void>;
    enableBatchActions?: boolean;
    rowActions?: OriginalRowAction_2<T>[];
    itemRenderer?: (item: T) => ReactElement;
    newButtonLabel?: string;
}

export declare const LoadingCentered: default_2.FC<LoadingCenteredProps>;

declare interface LoadingCenteredProps extends default_2.HTMLAttributes<HTMLDivElement> {
    loading?: boolean;
    size?: number;
    children?: default_2.ReactNode;
}

export declare const localFileExplorerFeature: StudioFeature;

export declare const LocalHealthCheck: () => JSX.Element | null;

export declare class LocalRouter implements StudioRouter {
    private navigate;
    private envId;
    private embedPrefix;
    constructor(navigate: ReturnType<typeof useNavigate>, envId: string, embedPrefix?: string);
    navigateToHome(): Promise<void>;
    getEnvironmentInfo(): string;
    navigateToEnvironmentInfo(): Promise<void>;
    getRuns(): string;
    getRunsActionRequired(): string;
    getDashboard(): string;
    navigateToDashboard(): Promise<void>;
    getWorkspaces(): string;
    getDebugWorkflows(): string;
    getDebugWorkflow(workflowId: string): string;
    navigateToDebugWorkflow(workflowId: string): Promise<void>;
    navigateToWorkspaces(): Promise<void>;
    getWorkspace(workspaceId: string): string;
    navigateToWorkspace(workspaceId: string): Promise<void>;
    getWorkflow(workflowId: string): string;
    navigateToWorkflow(workflowId: string): Promise<void>;
    getWorkflowDebug(workflowId: string): string;
    navigateToWorkflowDebug(workflowId: string): Promise<void>;
    navigateToChildWorkflow(workflowId: string, clickId: string | undefined): Promise<void>;
    getWorkspaceRuns(workspaceId: string): string;
    navigateToWorkspaceRuns(workspaceId: string): Promise<void>;
    getEmbedWorkflow(workflowId: string): string;
    getPreviewWorkflow(workflowId: string): string;
    getCurrentEnvironmentId(): string;
    getTheme(): 'local' | 'cloud';
}

/**
 * Provides the Loopstack SDK client for the current Studio environment.
 * The stream connection is ref-counted by its subscribers — no explicit
 * teardown is needed when the environment changes.
 */
export declare function LoopstackClientProvider({ children }: {
    children?: ReactNode;
}): JSX.Element;

export declare const MainLayout: ({ children, breadcrumbsData, headerMenu, }: {
    children: ReactNode;
    breadcrumbsData: BreadCrumbsData[];
    headerMenu?: ReactNode;
}) => JSX.Element;

declare interface OriginalBatchAction {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
    action: (selectedIds: string[]) => void | Promise<void>;
}

declare interface OriginalBatchAction_2 {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
    action: (selectedIds: string[]) => void | Promise<void>;
}

export declare interface OriginalRowAction<T extends Item = Item> {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    action: (item: T) => void | Promise<void>;
    condition?: (item: T) => boolean;
    disabled?: (item: T) => boolean;
    className?: string;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
}

declare interface OriginalRowAction_2<T extends Item_2 = Item_2> {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    action: (item: T) => void | Promise<void>;
    condition?: (item: T) => boolean;
    disabled?: (item: T) => boolean;
    className?: string;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
}

export declare const PageBreadcrumbs: React.FC<PageBreadcrumbsProps>;

declare interface PageBreadcrumbsProps {
    className?: string;
    breadcrumbData: BreadCrumbsData[];
}

declare type PanelId = 'runs' | 'preview' | 'files' | 'environment' | (string & {});

declare type PanelSize = 'small' | 'medium' | 'large';

export declare function Popover({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Root>): JSX.Element;

export declare function PopoverAnchor({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Anchor>): JSX.Element;

export declare function PopoverContent({ className, align, sideOffset, ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Content>): JSX.Element;

export declare function PopoverTrigger({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Trigger>): JSX.Element;

export declare function PreviewWorkbenchPage(): JSX.Element;

export declare function RadioGroup({ className, ...props }: React_2.ComponentProps<typeof RadioGroupPrimitive.Root>): JSX.Element;

export declare function RadioGroupItem({ className, ...props }: React_2.ComponentProps<typeof RadioGroupPrimitive.Item>): JSX.Element;

export declare const remoteFileExplorerFeature: StudioFeature;

export declare interface RowAction<T = any> {
    id: string;
    label: string;
    icon?: React.ReactNode;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
    action: (item: T) => Promise<void> | void;
    condition?: (item: T) => boolean;
    disabled?: (item: T) => boolean;
    className?: string;
}

declare interface RowAction_2<T = any> {
    id: string;
    label: string;
    icon?: React.ReactNode;
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
    action: (item: T) => Promise<void> | void;
    condition?: (item: T) => boolean;
    disabled?: (item: T) => boolean;
    className?: string;
}

export declare function RunsListPage(): JSX.Element;

export declare function RunsPage(): JSX.Element;

export declare function ScrollArea({ className, children, ...props }: React_2.ComponentProps<typeof ScrollAreaPrimitive.Root>): JSX.Element;

export declare function ScrollBar({ className, orientation, ...props }: React_2.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): JSX.Element;

export declare const secretsFeature: StudioFeature;

export declare function Select({ ...props }: React_2.ComponentProps<typeof SelectPrimitive.Root>): JSX.Element;

export declare function SelectContent({ className, children, position, align, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Content>): JSX.Element;

export declare function SelectGroup({ ...props }: React_2.ComponentProps<typeof SelectPrimitive.Group>): JSX.Element;

export declare function SelectItem({ className, children, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Item>): JSX.Element;

export declare function SelectLabel({ className, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Label>): JSX.Element;

export declare function SelectScrollDownButton({ className, ...props }: React_2.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): JSX.Element;

export declare function SelectScrollUpButton({ className, ...props }: React_2.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): JSX.Element;

export declare function SelectSeparator({ className, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Separator>): JSX.Element;

export declare function SelectTrigger({ className, size, children, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Trigger> & {
    size?: 'sm' | 'default';
}): JSX.Element;

export declare function SelectValue({ ...props }: React_2.ComponentProps<typeof SelectPrimitive.Value>): JSX.Element;

export declare function Separator({ className, orientation, decorative, ...props }: React_2.ComponentProps<typeof SeparatorPrimitive.Root>): JSX.Element;

export declare function Sheet({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Root>): JSX.Element;

export declare function SheetClose({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Close>): JSX.Element;

export declare function SheetContent({ className, children, side, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Content> & {
    side?: 'top' | 'right' | 'bottom' | 'left';
}): JSX.Element;

export declare function SheetDescription({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Description>): JSX.Element;

export declare function SheetFooter({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SheetHeader({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SheetTitle({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Title>): JSX.Element;

export declare function SheetTrigger({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Trigger>): JSX.Element;

export declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React_2.ComponentProps<'div'> & {
    side?: 'left' | 'right';
    variant?: 'sidebar' | 'floating' | 'inset';
    collapsible?: 'offcanvas' | 'icon' | 'none';
}): JSX.Element;

export declare function SidebarContent({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

declare type SidebarContextProps = {
    state: 'expanded' | 'collapsed';
    open: boolean;
    setOpen: (open: boolean) => void;
    openMobile: boolean;
    setOpenMobile: (open: boolean) => void;
    isMobile: boolean;
    toggleSidebar: () => void;
};

export declare function SidebarFooter({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SidebarGroup({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SidebarGroupAction({ className, asChild, ...props }: React_2.ComponentProps<'button'> & {
    asChild?: boolean;
}): JSX.Element;

export declare function SidebarGroupContent({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SidebarGroupLabel({ className, asChild, ...props }: React_2.ComponentProps<'div'> & {
    asChild?: boolean;
}): JSX.Element;

export declare function SidebarHeader({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SidebarInput({ className, ...props }: React_2.ComponentProps<typeof Input>): JSX.Element;

export declare function SidebarInset({ className, ...props }: React_2.ComponentProps<'main'>): JSX.Element;

export declare function SidebarInsetDiv({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SidebarMenu({ className, ...props }: React_2.ComponentProps<'ul'>): JSX.Element;

export declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React_2.ComponentProps<'button'> & {
    asChild?: boolean;
    showOnHover?: boolean;
}): JSX.Element;

export declare function SidebarMenuBadge({ className, ...props }: React_2.ComponentProps<'div'>): JSX.Element;

export declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React_2.ComponentProps<'button'> & {
    asChild?: boolean;
    isActive?: boolean;
    tooltip?: string | React_2.ComponentProps<typeof TooltipContent>;
} & VariantProps<typeof sidebarMenuButtonVariants>): JSX.Element;

declare const sidebarMenuButtonVariants: (props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function SidebarMenuDiv({ asChild, isActive, variant, size, tooltip, className, ...props }: React_2.ComponentProps<'div'> & {
    asChild?: boolean;
    isActive?: boolean;
    tooltip?: string | React_2.ComponentProps<typeof TooltipContent>;
} & VariantProps<typeof sidebarMenuButtonVariants>): JSX.Element;

export declare function SidebarMenuItem({ className, ...props }: React_2.ComponentProps<'li'>): JSX.Element;

export declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React_2.ComponentProps<'div'> & {
    showIcon?: boolean;
}): JSX.Element;

export declare function SidebarMenuSub({ className, ...props }: React_2.ComponentProps<'ul'>): JSX.Element;

export declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React_2.ComponentProps<'a'> & {
    asChild?: boolean;
    size?: 'sm' | 'md';
    isActive?: boolean;
}): JSX.Element;

export declare function SidebarMenuSubItem({ className, ...props }: React_2.ComponentProps<'li'>): JSX.Element;

export declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React_2.ComponentProps<'div'> & {
    defaultOpen?: boolean;
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
}): JSX.Element;

export declare function SidebarRail({ className, ...props }: React_2.ComponentProps<'button'>): JSX.Element;

export declare function SidebarSeparator({ className, ...props }: React_2.ComponentProps<typeof Separator>): JSX.Element;

export declare function SidebarTrigger({ className, onClick, ...props }: React_2.ComponentProps<typeof Button>): JSX.Element;

export declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): JSX.Element;

export declare function Slider({ className, defaultValue, value, min, max, ...props }: React_2.ComponentProps<typeof SliderPrimitive.Root>): JSX.Element;

export declare const Snackbar: default_2.FC<BaseSnackbarProps>;

declare interface StudioContext {
    router: StudioRouter;
    environment: Environment;
}

declare const StudioContext: Context<StudioContext | null>;

export declare interface StudioFeature {
    id: string;
    documentRenderers?: Record<string, ComponentType<DocumentRendererProps>>;
    sidebarPanel?: StudioFeatureSidebarPanel;
}

export declare interface StudioFeatureSidebarPanel {
    id: string;
    label: string;
    icon: ComponentType<{
        className?: string;
    }>;
    component: ComponentType<{
        workspaceId?: string;
    }>;
}

export declare function StudioLandingPage(): JSX.Element;

declare interface StudioPreferences {
    leftSidebarOpen: boolean;
    activePanel: PanelId | null;
    panelSizes: Partial<Record<PanelId, PanelSize>>;
    /** Workbench workflow area: legacy document tree or the canonical run view. */
    workbenchView: 'classic' | 'run';
}

declare interface StudioPreferencesContextType {
    preferences: StudioPreferences;
    setPreference: <K extends keyof StudioPreferences>(key: K, value: StudioPreferences[K]) => void;
}

export declare function StudioPreferencesProvider({ children }: {
    children: ReactNode;
}): JSX.Element;

export declare const StudioProvider: ({ children, router, environment, }: {
    children: ReactNode;
    router: StudioRouter;
    environment: Environment;
}) => JSX.Element;

export declare interface StudioRouter {
    navigateToHome(): Promise<void>;
    getEnvironmentInfo(): string;
    navigateToEnvironmentInfo(): Promise<void>;
    getRuns(): string;
    getRunsActionRequired(): string;
    getDashboard(): string;
    navigateToDashboard(): Promise<void>;
    getWorkspaces(): string;
    getDebugWorkflows(): string;
    getDebugWorkflow(workflowId: string): string;
    navigateToDebugWorkflow(workflowId: string): Promise<void>;
    navigateToWorkspaces(): Promise<void>;
    getWorkspace(workspaceId: string): string;
    navigateToWorkspace(workspaceId: string): Promise<void>;
    getWorkflow(workflowId: string): string;
    navigateToWorkflow(workflowId: string): Promise<void>;
    getWorkflowDebug(workflowId: string): string;
    navigateToWorkflowDebug(workflowId: string): Promise<void>;
    navigateToChildWorkflow(workflowId: string, clickId: string | undefined): Promise<void>;
    getWorkspaceRuns(workspaceId: string): string;
    navigateToWorkspaceRuns(workspaceId: string): Promise<void>;
    getEmbedWorkflow(workflowId: string): string;
    getPreviewWorkflow(workflowId: string): string;
    getCurrentEnvironmentId(): string;
    getTheme(): 'local' | 'cloud';
}

export declare const StudioSidebar: () => JSX.Element;

export declare function Switch({ className, ...props }: React_2.ComponentProps<typeof SwitchPrimitive.Root>): JSX.Element;

export declare function Table({ className, ...props }: React_2.ComponentProps<'table'>): JSX.Element;

export declare function TableBody({ className, ...props }: React_2.ComponentProps<'tbody'>): JSX.Element;

export declare function TableCaption({ className, ...props }: React_2.ComponentProps<'caption'>): JSX.Element;

export declare function TableCell({ className, ...props }: React_2.ComponentProps<'td'>): JSX.Element;

export declare function TableFooter({ className, ...props }: React_2.ComponentProps<'tfoot'>): JSX.Element;

export declare function TableHead({ className, ...props }: React_2.ComponentProps<'th'>): JSX.Element;

export declare function TableHeader({ className, ...props }: React_2.ComponentProps<'thead'>): JSX.Element;

export declare function TableRow({ className, ...props }: React_2.ComponentProps<'tr'>): JSX.Element;

export declare function Textarea({ className, ...props }: React_2.ComponentProps<'textarea'>): JSX.Element;

declare type ToastVariant = 'success' | 'error' | 'info' | 'warning' | 'loading';

export declare function Tooltip({ ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Root>): JSX.Element;

export declare function TooltipContent({ className, sideOffset, children, ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Content>): JSX.Element;

export declare function TooltipProvider({ delayDuration, ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Provider>): JSX.Element;

export declare function TooltipTrigger({ ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Trigger>): JSX.Element;

export { useAppsConfig }

export { useAvailableEnvironments }

/**
 * Batch delete workflows.
 */
export declare function useBatchDeleteWorkflows(): UseMutationResult<    {
deleted: string[];
failed: {
id: string;
error: string;
}[];
}, Error, string[], unknown>;

export { useBatchDeleteWorkspaces }

/**
 * Fetch child workflows by parentId.
 */
export declare function useChildWorkflows(parentId: string | undefined, enabled?: boolean): UseQueryResult<    {
id: string;
workflowName: string;
title: string | null;
run: number;
labels: string[];
status: WorkflowState;
hasError: boolean;
place: string;
createdAt: string;
updatedAt: string;
workspaceId: string;
parentId: string | null;
hasChildren: number;
}[]>;

export declare const useComponentOverrides: () => ComponentOverrides;

export { useCreateWorkflow }

export { useCreateWorkspace }

export { useDeleteWorkflow }

export { useDeleteWorkspace }

/**
 * Returns a Map of document configs keyed by documentName.
 * Document configs are fetched as part of the apps config and are global (same across all apps).
 */
export declare function useDocumentConfigs(): Map<string, StudioDocumentConfig>;

/**
 * Fetch a filtered, sorted, paginated list of workflows.
 */
export declare function useFilterWorkflows(searchTerm: string | undefined, filter: Record<string, string | null>, sortBy?: string, order?: string, page?: number, limit?: number): UseQueryResult<PaginatedInterface<    {
id: string;
workflowName: string;
title: string | null;
run: number;
labels: string[];
status: WorkflowState;
hasError: boolean;
place: string;
createdAt: string;
updatedAt: string;
workspaceId: string;
parentId: string | null;
hasChildren: number;
}>>;

/**
 * Fetch a filtered, sorted, paginated list of workspaces.
 */
export declare function useFilterWorkspaces(searchTerm: string | undefined, filter: Record<string, string>, sortBy?: string, order?: string, page?: number, limit?: number): UseQueryResult<PaginatedInterface<    {
id: string;
appName: string;
title: string;
isFavourite: boolean;
createdAt: string;
updatedAt: string;
}>>;

export declare function useIsMobile(): boolean;

export declare function useOptionalStudioPreferences(): StudioPreferencesContextType | null;

export declare function useReplaceEnvironments(): UseMutationResult<WorkspaceEnvironmentInterface[], Error, {
workspaceId: string;
environments: WorkspaceEnvironmentInterface[];
}, unknown>;

export declare function useResetEnvironment(): UseMutationResult<    {
success: boolean;
message: string;
}, Error, {
workspaceId: string;
slotId: string;
}, unknown>;

export declare const useRouter: (envId: string, embedPrefix?: string) => StudioRouter;

export { useSetFavouriteWorkspace }

export declare function useSidebar(): SidebarContextProps;

export declare const useStudio: () => StudioContext;

export declare const useStudioOptional: () => StudioContext | null;

export declare function useStudioPreferences(): StudioPreferencesContextType;

export { useUpdateWorkflow }

export { useUpdateWorkspace }

export { useWorkflow }

export { useWorkflowCheckpoints }

/**
 * Fetch workflow config by workflow name (the identifier stored on the workflow entity).
 */
export declare function useWorkflowConfigByName(workflowName: string | undefined): UseQueryResult<    {
workflowName: string;
title?: string | undefined;
description?: string | undefined;
schema?: JSONSchemaDefinition | undefined;
ui?: {
widgets?: {
widget: string;
enabledWhen?: string[] | undefined;
showWhen?: string[] | undefined;
options?: Record<string, any> | undefined;
}[] | undefined;
} | undefined;
transitions?: {
id: string;
from: string | string[];
to: string;
if?: string | boolean | undefined;
trigger?: string | undefined;
call?: {
tool: string;
id?: string | undefined;
args?: any;
assign?: Record<string, string | number | boolean | Record<string, any> | null> | undefined;
}[] | undefined;
assign?: Record<string, string | number | boolean | Record<string, any> | null> | undefined;
onError?: string | undefined;
debug?: boolean | undefined;
}[] | undefined;
}>;

export { useWorkflowSource }

export { useWorkflowStatus }

export { useWorkspace }

export declare function useWorkspaceEnvironments(workspaceId?: string): UseQueryResult<WorkspaceEnvironmentInterface[], Error>;

export declare function WorkbenchPage({ getPreviewUrl, getEnvironmentPreviewUrl, }?: {
    getPreviewUrl?: (workflowId: string) => string;
    getEnvironmentPreviewUrl?: (env: WorkspaceEnvironmentInterface, workflowId?: string) => string;
}): JSX.Element;

export declare const WorkflowDebugPage: default_2.FC;

export declare const WorkspacePage: () => JSX.Element;

export declare const WorkspaceRunsPage: () => JSX.Element;

export declare function WorkspacesPage(): JSX.Element;

export { }