@mdxui/do 2.1.1 → 4.0.0

package/dist/{agents-xcIn2dUB.d.ts → agents-2_r9e9i7.d.ts}

@@ -1,4 +1,215 @@
-import { ExecutionError, TokenUsage } from './schemas/index.js';
+import { EntityReference, ExecutionError, TokenUsage } from './schemas/index.js';
+
+/**
+ * Relationship Types - Semantic Graph Connections
+ *
+ * Relationships form a semantic knowledge graph connecting Things.
+ * Uses the $.Subject.predicate.Object pattern throughout.
+ *
+ * @remarks
+ * The Relationships table uses MergeTree with ORDER BY (toNs, toId, fromNs, fromId)
+ * optimized for reverse lookups ("who references me?").
+ *
+ * 64+ semantic predicates across categories:
+ * - Temporal: before, after, during, since, until...
+ * - Spatial: above, below, near, between, within...
+ * - Directional: through, toward, from, into, across...
+ * - Relational: of, about, for, including, regarding...
+ * - Causal: because, considering, but
+ */
+
+/**
+ * Core relationship record from database
+ */
+interface Relationship {
+    /** Unique relationship identifier */
+    relationshipId: string;
+    /** Semantic predicate type */
+    relationshipType: SemanticPredicate;
+    /** Source entity namespace */
+    fromNs: string;
+    /** Source entity type */
+    fromType: string;
+    /** Source entity ID */
+    fromId: string;
+    /** Target entity namespace */
+    toNs: string;
+    /** Target entity type */
+    toType: string;
+    /** Target entity ID */
+    toId: string;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Creator user ID */
+    createdBy: string;
+    /** Soft delete timestamp */
+    deletedAt?: Date | null;
+    /** Deleter user ID */
+    deletedBy?: string;
+    /** Additional relationship metadata */
+    metadata: RelationshipMetadata;
+}
+/**
+ * Semantic predicate categories
+ */
+type SemanticPredicateCategory = 'temporal' | 'spatial' | 'directional' | 'relational' | 'causal' | 'ownership' | 'membership' | 'dependency' | 'custom';
+/**
+ * Built-in semantic predicates
+ */
+type SemanticPredicate = 'before' | 'after' | 'during' | 'since' | 'until' | 'by' | 'at' | 'in' | 'on' | 'past' | 'throughout' | 'till' | 'above' | 'below' | 'under' | 'near' | 'between' | 'among' | 'beside' | 'within' | 'amid' | 'around' | 'behind' | 'beneath' | 'beyond' | 'inside' | 'upon' | 'outside' | 'over' | 'opposite' | 'underneath' | 'round' | 'through' | 'toward' | 'to' | 'from' | 'into' | 'across' | 'along' | 'against' | 'down' | 'off' | 'onto' | 'up' | 'via' | 'out' | 'with' | 'of' | 'about' | 'concerning' | 'for' | 'including' | 'regarding' | 'like' | 'as' | 'than' | 'unlike' | 'besides' | 'except' | 'despite' | 'without' | 'per' | 'because' | 'considering' | 'but' | 'owns' | 'worksFor' | 'contains' | 'belongsTo' | 'employs' | 'locatedAt' | 'handoff' | 'uses' | 'validates' | 'blocks' | 'dependsOn' | 'references' | 'parentOf' | 'childOf' | 'siblingOf' | string;
+/**
+ * Predicate definition with metadata
+ */
+interface PredicateDefinition {
+    /** Predicate name */
+    name: SemanticPredicate;
+    /** Category */
+    category: SemanticPredicateCategory;
+    /** Human-readable label */
+    label: string;
+    /** Description */
+    description: string;
+    /** Inverse predicate (e.g., 'owns' -> 'ownedBy') */
+    inverse?: SemanticPredicate;
+    /** Is this predicate symmetric? */
+    symmetric: boolean;
+    /** Is this predicate transitive? */
+    transitive: boolean;
+    /** Valid source types (empty = any) */
+    validFromTypes: string[];
+    /** Valid target types (empty = any) */
+    validToTypes: string[];
+}
+/**
+ * Additional metadata for relationships
+ */
+interface RelationshipMetadata {
+    /** Relationship strength/weight (0-1) */
+    weight?: number;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** Source of the relationship (manual, inferred, imported) */
+    source?: 'manual' | 'inferred' | 'imported' | 'system';
+    /** Start date (for temporal relationships) */
+    startDate?: Date;
+    /** End date (for temporal relationships) */
+    endDate?: Date;
+    /** Additional properties */
+    [key: string]: unknown;
+}
+/**
+ * Semantic triple representation ($.Subject.predicate.Object)
+ */
+interface SemanticTriple {
+    /** Subject (from) entity reference */
+    subject: EntityReference;
+    /** Predicate (relationship type) */
+    predicate: SemanticPredicate;
+    /** Object (to) entity reference */
+    object: EntityReference;
+}
+/**
+ * Graph query pattern for finding relationships
+ */
+interface GraphPattern {
+    /** Subject pattern (supports wildcards) */
+    subject?: Partial<EntityReference> & {
+        pattern?: string;
+    };
+    /** Predicate filter */
+    predicate?: SemanticPredicate | SemanticPredicate[];
+    /** Object pattern (supports wildcards) */
+    object?: Partial<EntityReference> & {
+        pattern?: string;
+    };
+    /** Maximum depth for traversal */
+    depth?: number;
+    /** Direction of traversal */
+    direction?: 'outgoing' | 'incoming' | 'both';
+}
+/**
+ * Relationship creation payload
+ */
+interface RelationshipCreateInput {
+    /** Predicate type */
+    relationshipType: SemanticPredicate;
+    /** Source entity */
+    from: EntityReference;
+    /** Target entity */
+    to: EntityReference;
+    /** Metadata */
+    metadata?: RelationshipMetadata;
+}
+/**
+ * Query filters for relationships
+ */
+interface RelationshipFilter {
+    /** Filter by predicate type */
+    predicates?: SemanticPredicate[];
+    /** Filter by source entity */
+    from?: Partial<EntityReference>;
+    /** Filter by target entity */
+    to?: Partial<EntityReference>;
+    /** Filter by category */
+    categories?: SemanticPredicateCategory[];
+    /** Include deleted */
+    includeDeleted?: boolean;
+    /** Filter by metadata */
+    metadata?: Partial<RelationshipMetadata>;
+    /** Date range */
+    createdAfter?: Date;
+    createdBefore?: Date;
+}
+/**
+ * Graph traversal result
+ */
+interface GraphTraversalResult {
+    /** Root entity */
+    root: EntityReference;
+    /** All nodes found */
+    nodes: EntityReference[];
+    /** All edges (relationships) found */
+    edges: Relationship[];
+    /** Traversal depth reached */
+    depth: number;
+    /** Paths from root to each node */
+    paths: GraphPath[];
+}
+/**
+ * A path in the graph
+ */
+interface GraphPath {
+    /** Starting node */
+    start: EntityReference;
+    /** Ending node */
+    end: EntityReference;
+    /** Edges traversed */
+    edges: Relationship[];
+    /** Total weight (sum of edge weights) */
+    totalWeight: number;
+    /** Path length (number of edges) */
+    length: number;
+}
+/**
+ * Statistics for the relationship graph
+ */
+interface GraphStats {
+    /** Total relationships */
+    totalRelationships: number;
+    /** Active relationships (not deleted) */
+    activeRelationships: number;
+    /** Count by predicate type */
+    byPredicate: Record<string, number>;
+    /** Count by category */
+    byCategory: Record<SemanticPredicateCategory, number>;
+    /** Average degree (connections per node) */
+    averageDegree: number;
+    /** Most connected nodes */
+    topConnectedNodes: Array<{
+        entity: EntityReference;
+        degree: number;
+    }>;
+}
 
 /**
  * Workflow Types - Business Process Orchestration
@@ -829,4 +1040,4 @@ interface AgentExecutionFilter {
     minRating?: number;
 }
 
-export type { AIStepConfig as A, AgentMetrics as B, ChoiceCondition as C, DatabaseStepConfig as D, EventTrigger as E, AgentExecution as F, AgentExecutionStatus as G, HttpStepConfig as H, AgentInput as I, AgentOutput as J, AgentArtifact as K, AgentTrace as L, ManualTrigger as M, NotificationConfig as N, AgentHandoff as O, GuardrailViolation as P, AgentFeedback as Q, RetryConfig as R, ScheduleTrigger as S, TriggerType as T, AgentFilter as U, AgentExecutionFilter as V, WorkflowStatus as W, Workflow as a, TriggerBase as b, WebhookTrigger as c, WorkflowTrigger as d, StepType as e, WorkflowStep as f, StepConfig as g, EventStepConfig as h, ErrorHandlingConfig as i, CompensationConfig as j, WorkflowConfig as k, ExecutionStatus as l, WorkflowExecution as m, TriggerData as n, ExecutionContext as o, StepExecution as p, WorkflowFilter as q, ExecutionFilter as r, Agent as s, AgentType as t, RoleCategory as u, AgentClassification as v, CharacterBible as w, AgentGuardrail as x, HandoffRule as y, AgentStatus as z };
+export type { AgentOutput as $, AIStepConfig as A, WorkflowFilter as B, ChoiceCondition as C, DatabaseStepConfig as D, EventTrigger as E, ExecutionFilter as F, GraphPattern as G, HttpStepConfig as H, Agent as I, AgentType as J, RoleCategory as K, AgentClassification as L, ManualTrigger as M, NotificationConfig as N, CharacterBible as O, PredicateDefinition as P, AgentGuardrail as Q, Relationship as R, SemanticPredicateCategory as S, TriggerType as T, HandoffRule as U, AgentStatus as V, WorkflowStatus as W, AgentMetrics as X, AgentExecution as Y, AgentExecutionStatus as Z, AgentInput as _, SemanticPredicate as a, AgentArtifact as a0, AgentTrace as a1, AgentHandoff as a2, GuardrailViolation as a3, AgentFeedback as a4, AgentFilter as a5, AgentExecutionFilter as a6, RelationshipMetadata as b, SemanticTriple as c, RelationshipCreateInput as d, RelationshipFilter as e, GraphTraversalResult as f, GraphPath as g, GraphStats as h, Workflow as i, TriggerBase as j, ScheduleTrigger as k, WebhookTrigger as l, WorkflowTrigger as m, StepType as n, WorkflowStep as o, StepConfig as p, EventStepConfig as q, RetryConfig as r, ErrorHandlingConfig as s, CompensationConfig as t, WorkflowConfig as u, ExecutionStatus as v, WorkflowExecution as w, TriggerData as x, ExecutionContext as y, StepExecution as z };

package/dist/app/index.d.ts

@@ -0,0 +1,347 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { d as DOShellConfig, c as DOCustomRoute } from '../config-CxvpD8Y6.js';
+import { a as BreadcrumbItemConfig } from '../breadcrumbs-C9Qn3S7d.js';
+import { Sidebar } from '@mdxui/primitives';
+import { useAuth } from '@workos-inc/authkit-react';
+export { DOClient, DOContextValue, DOProvider, DOProviderProps, useDO, useDOClient, useDOUrls, useDataProviderSafe, useSyncStatus } from '../providers/index.js';
+export { useQueryClient } from '@tanstack/react-query';
+import { z } from 'zod';
+import '../do-D27i5bU0.js';
+import '@mdxui/app';
+import '../capnweb-client-Bq78FtEA.js';
+
+/**
+ * DatabasesPage - Renders DataGridView with route params
+ *
+ * Route: /databases/:ns?/:type?
+ */
+declare function DatabasesPage(): react_jsx_runtime.JSX.Element;
+
+/**
+ * DocumentPage - Renders DocumentEditorView with route params
+ *
+ * Route: /things/$ns/$type/$id
+ */
+declare function DocumentPage(): react_jsx_runtime.JSX.Element;
+
+/**
+ * FunctionsPage - Renders FunctionEditorView
+ *
+ * Route: /functions
+ */
+declare function FunctionsPage(): react_jsx_runtime.JSX.Element;
+
+/**
+ * OverviewPage - Main dashboard landing page
+ *
+ * Shows stats, quick actions, and recent activity.
+ */
+declare function OverviewPage(): react_jsx_runtime.JSX.Element;
+
+/**
+ * ThingsPage - Renders DataBrowserView with route params
+ *
+ * Route: /things/$ns?/$type?
+ */
+declare function ThingsPage(): react_jsx_runtime.JSX.Element;
+
+interface DOAppProps {
+    /** Shell configuration */
+    config: DOShellConfig;
+    /** Optional custom content to render in the shell header */
+    headerContent?: React.ReactNode;
+    /** Optional custom content to render in the sidebar header */
+    sidebarHeaderContent?: React.ReactNode;
+}
+/**
+ * DOApp - Complete routed DO Admin Dashboard application with authentication
+ *
+ * This is the main entry point for using DO Admin with WorkOS authentication and routing.
+ * It sets up all necessary providers, routing, and the shell.
+ *
+ * @example
+ * ```tsx
+ * import { DOApp } from '@mdxui/do'
+ *
+ * function App() {
+ *   return (
+ *     <DOApp
+ *       config={{
+ *         do: {
+ *           apiEndpoint: 'https://api.do.ai',
+ *           authMethod: 'jwt',
+ *           bindings: [],
+ *           realTimeUpdates: true,
+ *         },
+ *         identity: {
+ *           clientId: 'client_xxx',
+ *           devMode: true,
+ *         },
+ *         branding: {
+ *           name: 'My DO Admin',
+ *         },
+ *         defaultNamespace: 'production',
+ *       }}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function DOApp({ config, headerContent, sidebarHeaderContent, }: DOAppProps): react_jsx_runtime.JSX.Element;
+
+interface AppProvidersProps {
+    config: DOShellConfig;
+    children: ReactNode;
+}
+/**
+ * AppProviders - Composed provider hierarchy for DOShell
+ *
+ * @example
+ * ```tsx
+ * <AppProviders
+ *   config={{
+ *     do: { apiEndpoint: '...', authMethod: 'jwt', bindings: [], realTimeUpdates: true },
+ *     identity: { clientId: 'client_xxx', devMode: true },
+ *   }}
+ * >
+ *   <DOShell />
+ * </AppProviders>
+ * ```
+ */
+declare function AppProviders({ config, children }: AppProvidersProps): react_jsx_runtime.JSX.Element;
+
+interface AuthGateProps {
+    children: ReactNode;
+}
+/**
+ * AuthGate handles authentication state and shows appropriate UI:
+ * - Loading state while checking auth
+ * - Landing page or redirect when not authenticated
+ * - Children (dashboard) when authenticated
+ */
+declare function AuthGate({ children }: AuthGateProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Static config context value (no state, just config)
+ */
+interface DOConfigContextValue {
+    /** Merged shell configuration */
+    config: DOShellConfig;
+}
+interface DOConfigProviderProps {
+    config: DOShellConfig;
+    children: ReactNode;
+}
+/**
+ * DOConfigProvider - Provides static shell configuration
+ *
+ * This is a minimal context for static config only.
+ * Dynamic state (endpoint, namespace) is managed via TanStack Query.
+ */
+declare function DOConfigProvider({ config, children }: DOConfigProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access static shell configuration
+ */
+declare function useDOConfig(): DOConfigContextValue;
+/**
+ * Hook to access enabled routes configuration
+ */
+declare function useDORoutes(): Partial<Record<string, boolean>>;
+/**
+ * Hook to access custom routes
+ */
+declare function useDOCustomRoutes(): DOCustomRoute[];
+
+interface DOShellProps {
+    /** Children to render in the main content area (typically TanStack Router Outlet) */
+    children: React.ReactNode;
+    /** Optional header content for the sidebar */
+    sidebarHeaderContent?: React.ReactNode;
+    /** Optional content to render in the header after breadcrumbs */
+    headerContent?: React.ReactNode;
+    /**
+     * Breadcrumb items to display.
+     * If not provided, auto-generates from current route.
+     * Pass empty array to disable breadcrumbs.
+     */
+    breadcrumbs?: BreadcrumbItemConfig[];
+}
+/**
+ * DOShell - Main layout wrapper for the DO Admin Dashboard.
+ *
+ * This layout provides:
+ * - Authentication gate (shows landing page if not authenticated)
+ * - A collapsible sidebar with navigation on the left
+ * - A main content area with a header containing breadcrumbs
+ * - Toast notifications via Sonner
+ * - Responsive design that works on mobile and desktop
+ *
+ * Uses TanStack Router for navigation.
+ *
+ * @example
+ * ```tsx
+ * <DOShell headerContent={<SearchBar />}>
+ *   <Outlet />
+ * </DOShell>
+ * ```
+ */
+declare function DOShell({ children, sidebarHeaderContent, headerContent, breadcrumbs: breadcrumbsProp, }: DOShellProps): react_jsx_runtime.JSX.Element;
+
+interface DOShellNavProps extends React.ComponentProps<typeof Sidebar> {
+    /** Optional header content to display at the top of the sidebar */
+    headerContent?: React.ReactNode;
+}
+/**
+ * DOShellNav - Sidebar navigation component for the DO Shell.
+ *
+ * Features:
+ * - Highlights active route based on current location
+ * - Uses lucide-react icons for each navigation item
+ * - Collapsible on mobile via the Sidebar component
+ * - Supports custom header content
+ * - Routes can be enabled/disabled via config
+ */
+declare function DOShellNav({ headerContent, ...props }: DOShellNavProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hook to access identity/auth state.
+ * Re-exports useAuth from WorkOS AuthKit for convenience.
+ */
+declare const useIdentity: typeof useAuth;
+interface DOIdentityProviderProps {
+    children: ReactNode;
+}
+/**
+ * Identity provider that wraps the shell with WorkOS AuthKit authentication.
+ *
+ * Provides authentication context to all child components.
+ */
+declare function DOIdentityProvider({ children }: DOIdentityProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UserMenuProps {
+    /** Whether to show in compact mode (icon only) */
+    compact?: boolean;
+}
+/**
+ * UserMenu - User dropdown with profile info and sign out
+ *
+ * Displays the current user's avatar and name, with options for
+ * settings and signing out.
+ */
+declare function UserMenu({ compact }: UserMenuProps): react_jsx_runtime.JSX.Element | null;
+
+interface PlaceholderPageProps {
+    /** Title for the page */
+    title: string;
+    /** Description of what this page will contain */
+    description?: string;
+}
+/**
+ * PlaceholderPage - Shows a "coming soon" message for unimplemented routes
+ */
+declare function PlaceholderPage({ title, description }: PlaceholderPageProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Route parameter schemas for DO Shell routes
+ *
+ * These Zod schemas define and validate route parameters.
+ */
+
+/**
+ * Schema for database route params
+ */
+declare const DatabaseRouteParams: z.ZodObject<{
+    ns: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: string | undefined;
+    ns?: string | undefined;
+}, {
+    type?: string | undefined;
+    ns?: string | undefined;
+}>;
+type DatabaseRouteParamsType = z.infer<typeof DatabaseRouteParams>;
+/**
+ * Schema for things browse route params
+ */
+declare const ThingsRouteParams: z.ZodObject<{
+    ns: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: string | undefined;
+    ns?: string | undefined;
+}, {
+    type?: string | undefined;
+    ns?: string | undefined;
+}>;
+type ThingsRouteParamsType = z.infer<typeof ThingsRouteParams>;
+/**
+ * Schema for document route params
+ */
+declare const DocumentRouteParams: z.ZodObject<{
+    ns: z.ZodString;
+    type: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: string;
+    ns: string;
+}, {
+    id: string;
+    type: string;
+    ns: string;
+}>;
+type DocumentRouteParamsType = z.infer<typeof DocumentRouteParams>;
+/**
+ * Schema for generic type-filtered route params
+ */
+declare const TypeFilteredRouteParams: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: string | undefined;
+}, {
+    type?: string | undefined;
+}>;
+type TypeFilteredRouteParamsType = z.infer<typeof TypeFilteredRouteParams>;
+
+/**
+ * DO Shell Routes
+ *
+ * Route definitions and parameter schemas for the DO Admin Dashboard.
+ */
+
+/**
+ * Route paths for DO Shell navigation
+ *
+ * These paths are used throughout the shell for navigation links
+ * and route matching.
+ */
+declare const doRoutePaths: {
+    readonly overview: "/";
+    readonly agents: "/agents";
+    readonly functions: "/functions";
+    readonly workflows: "/workflows";
+    readonly databases: "/databases";
+    readonly databaseTable: "/databases/:ns/:type";
+    readonly things: "/things";
+    readonly thingsBrowse: "/things/:ns/:type?";
+    readonly document: "/things/:ns/:type/:id";
+    readonly nouns: "/nouns";
+    readonly verbs: "/verbs";
+    readonly actions: "/actions";
+    readonly relationships: "/relationships";
+    readonly events: "/events";
+    readonly customers: "/customers";
+    readonly subscriptions: "/subscriptions";
+    readonly integrations: "/integrations";
+    readonly orgs: "/orgs";
+    readonly roles: "/roles";
+    readonly users: "/users";
+    readonly apiKeys: "/api-keys";
+    readonly settings: "/settings";
+};
+type DORoutePath = typeof doRoutePaths[keyof typeof doRoutePaths];
+
+export { AppProviders, type AppProvidersProps, AuthGate, type AuthGateProps, DOApp, type DOAppProps, type DOConfigContextValue, DOConfigProvider, DOIdentityProvider, type DOIdentityProviderProps, type DORoutePath, DOShell, DOShellNav, type DOShellNavProps, type DOShellProps, DatabaseRouteParams, type DatabaseRouteParamsType, DatabasesPage, DocumentPage, DocumentRouteParams, type DocumentRouteParamsType, FunctionsPage, OverviewPage, PlaceholderPage, ThingsPage, ThingsRouteParams, type ThingsRouteParamsType, TypeFilteredRouteParams, type TypeFilteredRouteParamsType, UserMenu, doRoutePaths, useDOConfig, useDOCustomRoutes, useDORoutes, useIdentity };

package/dist/app/index.js

@@ -0,0 +1,14 @@
+export { AppProviders, AuthGate, DOApp, DOConfigProvider, DOIdentityProvider, DOShell, DOShellNav, DatabaseRouteParams, DatabasesPage, DocumentPage, DocumentRouteParams, FunctionsPage, OverviewPage, PlaceholderPage, ThingsPage, ThingsRouteParams, TypeFilteredRouteParams, UserMenu, doRoutePaths, useDOConfig, useDOCustomRoutes, useDORoutes, useIdentity } from '../chunk-KT52UU3U.js';
+import '../chunk-7UFINK3Q.js';
+import '../chunk-JJLAES6W.js';
+import '../chunk-GKSP5RIA.js';
+import '../chunk-NA652ART.js';
+import '../chunk-5SHZZC7L.js';
+import '../chunk-4KXVN3EQ.js';
+export { DOProvider, useDO, useDOClient, useDOUrls, useDataProviderSafe, useQueryClient, useSyncStatus } from '../chunk-WMNT4OIE.js';
+import '../chunk-OVLO7UOH.js';
+import '../chunk-3XKYQRXY.js';
+import '../chunk-Y52IEYVM.js';
+import '../chunk-GGO5GW72.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/app/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/breadcrumbs-C9Qn3S7d.d.ts

@@ -0,0 +1,81 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+
+/**
+ * Props for the Link component
+ */
+interface BreadcrumbLinkProps {
+    href: string;
+    children: React.ReactNode;
+    className?: string;
+    onClick?: () => void;
+}
+/**
+ * Single breadcrumb item configuration
+ */
+interface BreadcrumbItemConfig {
+    /** Display label */
+    label: string;
+    /** Route path - last item should not have href */
+    href?: string;
+}
+/**
+ * Props for the Breadcrumbs component
+ */
+interface BreadcrumbsProps {
+    /** Array of breadcrumb items */
+    items: BreadcrumbItemConfig[];
+    /** Custom link component (e.g., Next.js Link, TanStack Link) */
+    LinkComponent?: React.ComponentType<BreadcrumbLinkProps>;
+    /** Additional class names */
+    className?: string;
+    /** Maximum items to show before collapsing */
+    maxItems?: number;
+    /** Custom separator element */
+    separator?: React.ReactNode;
+}
+/**
+ * Breadcrumbs provides navigation context showing the user's location.
+ *
+ * Features:
+ * - Router-agnostic - works with any Link component
+ * - Automatic collapse with dropdown for long paths
+ * - Accessible breadcrumb semantics
+ * - Custom separator support
+ *
+ * @example
+ * ```tsx
+ * // With default anchor tags
+ * <Breadcrumbs
+ *   items={[
+ *     { label: 'Home', href: '/' },
+ *     { label: 'Users', href: '/users' },
+ *     { label: 'John Doe' },
+ *   ]}
+ * />
+ *
+ * // With TanStack Router Link
+ * import { Link } from '@tanstack/react-router'
+ *
+ * <Breadcrumbs
+ *   items={breadcrumbItems}
+ *   LinkComponent={({ href, children, className }) => (
+ *     <Link to={href} className={className}>{children}</Link>
+ *   )}
+ * />
+ *
+ * // With Next.js Link
+ * import NextLink from 'next/link'
+ *
+ * <Breadcrumbs
+ *   items={breadcrumbItems}
+ *   LinkComponent={NextLink}
+ * />
+ * ```
+ */
+declare function Breadcrumbs({ items, LinkComponent, className, maxItems, separator, }: BreadcrumbsProps): react_jsx_runtime.JSX.Element | null;
+declare namespace Breadcrumbs {
+    var displayName: string;
+}
+
+export { type BreadcrumbLinkProps as B, type BreadcrumbItemConfig as a, type BreadcrumbsProps as b, Breadcrumbs as c };