import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
import { ApiV1AuthApi } from '../../client/api-client';
import { ApiV1ConfigApi } from '../../client/api-client';
import { ApiV1DashboardApi } from '../../client/api-client';
import { ApiV1DocumentsApi } from '../../client/api-client';
import { ApiV1NamespacesApi } from '../../client/api-client';
import { ApiV1PipelinesApi } from '../../client/api-client';
import { ApiV1ProcessorApi } from '../../client/api-client';
import { ApiV1WorkflowsApi } from '../../client/api-client';
import { ApiV1WorkspacesApi } from '../../client/api-client';
import { ApiV1WorkspacesApiWorkspaceControllerCreateWorkspaceRequest } from '../../client/api-client';
import { ApiV1WorkspacesApiWorkspaceControllerUpdateWorkspaceRequest } from '../../client/api-client';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import { AxiosResponse } from 'axios';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { ClassProp } from 'class-variance-authority/types';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { ComponentType } from 'react';
import { Context } from 'react';
import { default as default_2 } from 'react';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { Drawer as Drawer_2 } from 'vaul';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import { ExternalToast } from 'sonner';
import { JSX } from 'react/jsx-runtime';
import * as LabelPrimitive from '@radix-ui/react-label';
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 * as SwitchPrimitive from '@radix-ui/react-switch';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { UseMutationResult } from '@tanstack/react-query';
import { useNavigate } from 'react-router-dom';
import { UseQueryResult } from '@tanstack/react-query';
import { VariantProps } from 'class-variance-authority';
import { WorkspaceConfigDto } from '../../../../client/api-client';
import { WorkspaceConfigDto as WorkspaceConfigDto_2 } from '../../client/api-client';
import { WorkspaceControllerBatchDeleteWorkspaces200Response } from '../../client/api-client';
import { WorkspaceControllerGetWorkspaces200Response } from '../../client/api-client';
import { WorkspaceDto } from '../../client/api-client';
import { WorkspaceItemDto } from '../../../../client/api-client';
import { WorkspaceItemDto as WorkspaceItemDto_2 } from '../../client/api-client';

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;
}

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) => 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>;
}

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';
}

export declare function createApiClient(environment: Environment): {
    auth: ApiV1AuthApi;
};

export declare interface CreateWorkspaceProps {
    types: WorkspaceConfigDto[];
    workspace?: WorkspaceItemDto;
    onSuccess: () => 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, string[]>;
    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, string[]>;
    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, string[]>;
    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;
}

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: WorkspaceConfigDto_2[];
    workspace: WorkspaceItemDto_2;
    onSuccess: () => void;
}

export declare function EmbedWorkbenchPage(): JSX.Element;

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

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

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

export declare const eventBus: EventEmitter;

declare class EventEmitter {
    private events;
    on(event: string, listener: (...args: any[]) => void): () => void;
    emit(event: string, ...args: unknown[]): void;
}

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;

export declare function InvalidationEventsProvider(): null;

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, string[]>;
    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 LocalHealthCheck: () => JSX.Element | null;

export declare class LocalRouter implements StudioRouter {
    private navigate;
    private envId;
    constructor(navigate: ReturnType<typeof useNavigate>, envId: string);
    navigateToHome(): Promise<void>;
    navigateToEnvironmentInfo(): Promise<void>;
    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>;
    getPipeline(pipelineId: string): string;
    navigateToPipeline(pipelineId: string): Promise<void>;
    getPipelineDebug(pipelineId: string): string;
    navigateToPipelineDebug(pipelineId: string): Promise<void>;
    navigateToWorkflow(pipelineId: string, workflowId: string, clickId: string | undefined): Promise<void>;
    navigateToPipelineNamespace(workspaceId: string, pipelineId: string, namespaceId: string): Promise<void>;
    getEmbedPipeline(pipelineId: string): string;
    getCurrentEnvironmentId(): string;
    getTheme(): 'local' | 'cloud';
}

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[];
}

export declare const PipelineDebugPage: default_2.FC;

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 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 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 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 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>;

export declare function SseProvider(): null;

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

declare const StudioContext: Context<StudioContext | null>;

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

export declare interface StudioRouter {
    navigateToHome(): Promise<void>;
    navigateToEnvironmentInfo(): Promise<void>;
    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>;
    getPipeline(pipelineId: string): string;
    navigateToPipeline(pipelineId: string): Promise<void>;
    getPipelineDebug(pipelineId: string): string;
    navigateToPipelineDebug(pipelineId: string): Promise<void>;
    navigateToWorkflow(pipelineId: string, workflowId: string, clickId: string | undefined): Promise<void>;
    navigateToPipelineNamespace(workspaceId: string, pipelineId: string, namespaceId: string): Promise<void>;
    getEmbedPipeline(pipelineId: string): string;
    getCurrentEnvironmentId(): string;
    getTheme(): 'local' | 'cloud';
}

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 declare function useApiClient(): {
    envKey: string;
    api: {
        ApiV1AuthApi: ApiV1AuthApi;
        ApiV1DashboardApi: ApiV1DashboardApi;
        ApiV1ConfigApi: ApiV1ConfigApi;
        ApiV1DocumentsApi: ApiV1DocumentsApi;
        ApiV1NamespacesApi: ApiV1NamespacesApi;
        ApiV1PipelinesApi: ApiV1PipelinesApi;
        ApiV1ProcessorApi: ApiV1ProcessorApi;
        ApiV1WorkflowsApi: ApiV1WorkflowsApi;
        ApiV1WorkspacesApi: ApiV1WorkspacesApi;
    };
};

export declare function useBatchDeleteWorkspaces(): UseMutationResult<AxiosResponse<WorkspaceControllerBatchDeleteWorkspaces200Response, any, {}>, Error, string[], unknown>;

export declare const useComponentOverrides: () => ComponentOverrides;

export declare function useCreateWorkspace(): UseMutationResult<AxiosResponse<WorkspaceDto, any, {}>, Error, ApiV1WorkspacesApiWorkspaceControllerCreateWorkspaceRequest, unknown>;

export declare function useDeleteWorkspace(): UseMutationResult<AxiosResponse<void, any, {}>, Error, string, unknown>;

export declare function useFilterWorkspaces(searchTerm: string | undefined, filter: Record<string, string>, sortBy?: string, order?: string, page?: number, limit?: number): UseQueryResult<WorkspaceControllerGetWorkspaces200Response, Error>;

export declare function useIsMobile(): boolean;

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

export declare function useSetFavouriteWorkspace(): UseMutationResult<AxiosResponse<WorkspaceItemDto_2, any, {}>, Error, {
id: string;
isFavourite: boolean;
}, unknown>;

export declare function useSidebar(): SidebarContextProps;

export declare const useStudio: () => StudioContext;

export declare function useUpdateWorkspace(): UseMutationResult<AxiosResponse<WorkspaceDto, any, {}>, Error, ApiV1WorkspacesApiWorkspaceControllerUpdateWorkspaceRequest, unknown>;

export declare function useWorkspace(id: string | undefined): UseQueryResult<WorkspaceDto, Error>;

export declare function WorkbenchPage(): JSX.Element;

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

export declare function WorkspacesPage(): JSX.Element;

export { }
