@mdxui/do 2.1.1

package/dist/index.d.ts

@@ -0,0 +1,1012 @@
+export { AIModel, APIKey, APIKeyFilter, APIKeyPermissions, Address, AgentArtifactResponseSchema, AgentClassificationResponseSchema, AgentExecuteInputSchema, AgentExecutionFilterSchema, AgentExecutionResponse, AgentExecutionResponseSchema, AgentFeedbackInputSchema, AgentFeedbackResponseSchema, AgentFilterSchema, AgentGuardrailResponseSchema, AgentHandoffResponseSchema, AgentInputResponseSchema, AgentMetricsResponse, AgentMetricsResponseSchema, AgentOutputResponseSchema, AgentResponse, AgentResponseSchema, AgentTraceResponseSchema, AgentTypeResponseSchema, AgenticFunction, ApiKeyConfig, AppError, AuditEntry, AuthField, AuthenticationConfig, AuthenticationType, BaseError, BasicAuthConfig, BillingInfo, CellEditorProps, CellEditorType, CellRendererProps, CellValue, CharacterBibleResponseSchema, CodeFunction, ColumnEditorPanelProps, CompensationConfigResponseSchema, ConnectionFilter, ConnectionStatus, CustomAuthConfig, DBRecord, DOSQLResult, DOStorageInfo, DOStorageSchema, DataTypeCategory, DatabaseEditorProps, DatabaseGridProps, DatabaseSidebarProps, DatabaseToolbarProps, DateRangeFilter, DateResponseSchema, DeviceInfo, EditHistoryState, EditOperation, EntityReferenceResponseSchema, EntityReferenceSchema, EntityRelationshipsResultResponse, EntityRelationshipsResultResponseSchema, ErrorHandlingConfigResponseSchema, EscalationRule, EventDefinition, EventFilter, EventMetadata, EventQueryResult, EventReplayRequest, EventSource, EventStats, EventStream, EventSubscription, EventTimelineEntry, ExecutionContextResponseSchema, ExecutionErrorResponseSchema, ExecutionFilterSchema, FieldValidation, FilterSpec, ForeignKeyReference, Function, FunctionAgentClassification, FunctionAgentGuardrail, FunctionBase, FunctionCategory, FunctionExecution, FunctionExecutionStatus, FunctionFilter, FunctionHandoffRule, GenerativeFunction, GraphPath, GraphPathResponseSchema, GraphPattern, GraphPatternSchema, GraphStats, GraphStatsResponse, GraphStatsResponseSchema, GraphTraversalResult, GraphTraversalResultResponse, GraphTraversalResultResponseSchema, GuardrailViolationResponseSchema, HandoffRuleResponseSchema, HttpRequest, HttpResponse, HumanFunction, Integration, IntegrationAction, IntegrationCategory, IntegrationConnection, IntegrationError, IntegrationExecution, IntegrationField, IntegrationFilter, IntegrationSearch, IntegrationSource, IntegrationTrigger, InvitationStatus, MongoArrayOperators, MongoComparisonOperators, MongoElementOperators, MongoFieldOperators, MongoLogicalOperators, MongoProjection, MongoQuery, MongoSort, MongoStringOperators, MongoUpdateOperators, NotFoundError, NotificationPreferences, OAuth2Config, OperationEvent, OperationEventType, OptionalDateResponseSchema, Organization, OrganizationFilter, OrganizationInvitation, OrganizationMember, OrganizationMembership, OrganizationPlan, OrganizationRole, OrganizationSettings, OrganizationType, PaginatedResult, PaginatedResultResponseSchema, PaginationParams, PartialEntityReferenceSchema, PermissionError, PlanTier, PredicateDefinition, QueryStyle, RateLimitError, RecordMetadata, Relationship, RelationshipCreateInput, RelationshipCreateInputSchema, RelationshipEdge, RelationshipFilter, RelationshipFilterSchema, RelationshipMetadata, RelationshipMetadataResponseSchema, RelationshipMetadataSchema, RelationshipResponse, RelationshipResponseSchema, RelationshipsPanelProps, ReminderRule, ReplayTarget, ResourcePermission, RetryConfigResponseSchema, RowEditorPanelProps, SQLCondition, SQLEditorPanelProps, SQLOperator, SQLOrderBy, SQLWhereClause, SQLiteDataType, SQLiteStorageClass, SQLiteTypeAffinity, SSOConfig, SchemaOperation, SchemaVisualizerProps, SemanticEvent, SemanticId, SemanticIdComponents, SemanticPredicate, SemanticPredicateCategory, SemanticTriple, Session, SoftDeletable, SortParams, SortSpec, StepConfigResponseSchema, StepExecutionResponseSchema, SubscriptionStatus, TableAlterChanges, TableColumn, TableConstraint, TableDefinition, TableIndex, TableNode, TableTrigger, ThingCreateInputSchema, ThingDataSchema, ThingDeleteOptionsSchema, ThingFilterSchema, ThingPaginationSchema, ThingQueryResultResponse, ThingQueryResultResponseSchema, ThingResponse, ThingResponseSchema, ThingSortSchema, ThingUpdateInputSchema, ThingVersionResponse, ThingVersionResponseSchema, TokenUsageResponseSchema, ToolDefinition, TriggerDataResponseSchema, TypeStatsResponse, TypeStatsResponseSchema, UnifiedQuery, UsageLimits, UsageMetrics, UseEditHistoryReturn, User, UserFilter, UserPreferences, UserRole, ValidatedAgentExecutionFilter, ValidatedAgentFilter, ValidatedExecutionFilter, ValidatedRelationshipCreateInput, ValidatedRelationshipFilter, ValidatedThingCreateInput, ValidatedThingFilter, ValidatedThingUpdateInput, ValidatedWorkflowFilter, ValidationErrorData, WorkflowConfigResponseSchema, WorkflowExecutionResponse, WorkflowExecutionResponseSchema, WorkflowFilterSchema, WorkflowResponse, WorkflowResponseSchema, WorkflowStepResponseSchema, WorkflowTriggerInputSchema, WorkflowTriggerResponseSchema, isAppError, isNotFoundError, isPermissionError, isRateLimitError, isValidationErrorData } from './types/index.js';
+export { DOContextValue, DOProvider, DOProviderProps, useDO, useDOUrls, useDataProviderSafe, useSyncStatus } from './providers/index.js';
+export { BaseRecord, DO, DOAdminContextValue, DOProps, DeleteThingOptions, EntityRelationshipsData, ExecuteAgentInput, SubmitAgentFeedbackInput, UseAgentExecutionResult, UseAgentExecutionsResult, UseAgentMetricsResult, UseAgentResult, UseAgentsResult, UseCancelExecutionResult, UseCreateAgentResult, UseCreateRelationshipResult, UseCreateThingResult, UseCreateWorkflowResult, UseDOConfig, UseDOResult, UseDeleteAgentResult, UseDeleteRelationshipResult, UseDeleteThingResult, UseDeleteWorkflowResult, UseEntityRelationshipsResult, UseExecuteAgentResult, UseGraphStatsResult, UseGraphTraversalResult, UseRelationshipsResult, UseSubmitAgentFeedbackResult, UseThingResult, UseThingVersionsResult, UseThingsResult, UseTriggerWorkflowResult, UseTypeStatsResult, UseUpdateAgentResult, UseUpdateThingResult, UseUpdateWorkflowResult, UseWorkflowExecutionResult, UseWorkflowExecutionsResult, UseWorkflowResult, UseWorkflowsResult, agentsKeys, relationshipsKeys, thingsKeys, useAgent, useAgentExecution, useAgentExecutions, useAgentMetrics, useAgents, useCancelExecution, useCreateAgent, useCreateRelationship, useCreateThing, useCreateWorkflow, useDOAdmin, useDOContext, useDOResource, useDeleteAgent, useDeleteRelationship, useDeleteThing, useDeleteWorkflow, useEntityRelationships, useExecuteAgent, useGraphStats, useGraphTraversal, useIsDOEnabled, useRelationships, useSubmitAgentFeedback, useThing, useThingVersions, useThings, useTriggerWorkflow, useTypeStats, useUpdateAgent, useUpdateThing, useUpdateWorkflow, useWorkflow, useWorkflowExecution, useWorkflowExecutions, useWorkflows, workflowsKeys } from './hooks/index.js';
+export { WorkflowContext, use$ } from '@dotdo/react';
+export { AdminError, AdminErrorCode, AdminErrorDetails, CacheConfig, CreateParams, CreateResult, DataProvider, DataProviderConfig, DeleteManyParams, DeleteManyResult, DeleteParams, DeleteResult, AdminContextValue as DotdoAdminContextValue, AdminProvider as DotdoAdminProvider, DotdoDataProvider, DotdoDataProviderConfig, FilterOperator, GetListParams, GetListResult, GetManyParams, GetManyResult, GetOneParams, GetOneResult, InferredField, OptimisticConfig, QueryFilter, ResourceConfig, ResourceDefinition, SortOrder, UpdateParams, UpdateResult, createCacheKey, createResourceFromSchema, formatAdminError, inferFieldsFromSchema, invalidateCache, isAdminError, useAdminContext, useOptimisticUpdate } from '@dotdo/react/admin';
+export { AgentExecutePanel, AgentExecutePanelProps, AgentFeedbackPanel, AgentFeedbackPanelProps, AgentHistoryTable, AgentHistoryTableProps, AgentsGrid, AgentsGridProps, ConfirmDialog, ConfirmDialogProps, DOErrorBoundary, DOErrorBoundaryProps, DOHeader, DOHeaderProps, DOShell, DOShellProps, DOSidebar, DOSidebarHeader, DOSidebarHeaderProps, DOSidebarProps, NavItem, StatCardData, StatsCards, StatsCardsProps, SyncIndicatorState, SyncStatusIndicator, SyncStatusIndicatorProps, ThingForm, ThingFormData, ThingFormDialog, ThingFormDialogProps, ThingFormErrors, ThingFormProps, ThingsList, ThingsListProps, ThingsPage, ThingsPageProps, Toast, ToastContainer, ToastContainerProps, ToastNotificationProps, ToastProvider, ToastProviderProps, ToastType, TriggerWorkflowDialog, TriggerWorkflowDialogProps, WorkflowExecutionView, WorkflowExecutionViewProps, WorkflowsList, WorkflowsListProps, defaultNavItems, defaultStats, useErrorBoundary, useShell, useToast } from './components/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { ReactNode, ComponentType } from 'react';
+import { GetListParams, GetListResult, GetOneParams, GetOneResult, GetManyParams, GetManyResult, CreateParams, CreateResult, UpdateParams, UpdateResult, DeleteParams, DeleteResult } from '@mdxui/app';
+import { D as DOAdminConfig } from './do-CaQVueZw.js';
+export { j as ConflictResolver, C as ConflictStrategy, d as DOAlarm, f as DOBinding, b as DOClassType, h as DOHealthCheck, c as DOInstance, i as DOMetrics, g as DORPCMethod, a as DOStatus, e as DOStorageEntry, O as OfflineConfig, S as SyncStatus } from './do-CaQVueZw.js';
+import { d as ThingSort } from './thing-DtI25yZh.js';
+export { N as Namespace, g as SemanticProperty, S as SemanticType, T as Thing, b as ThingCreateInput, f as ThingData, i as ThingDeleteOptions, c as ThingFilter, e as ThingPagination, a as ThingQueryResult, h as ThingUpdateInput, j as ThingVersion, k as TypeStats } from './thing-DtI25yZh.js';
+import { ClassValue } from 'clsx';
+export { EntityReference, ExecutionError, PaginatedResponse, Pagination, SortDirection, TokenUsage } from './schemas/index.js';
+export { A as AIStepConfig, s as Agent, K as AgentArtifact, v as AgentClassification, F as AgentExecution, V as AgentExecutionFilter, G as AgentExecutionStatus, Q as AgentFeedback, U as AgentFilter, x as AgentGuardrail, O as AgentHandoff, I as AgentInput, B as AgentMetrics, J as AgentOutput, z as AgentStatus, L as AgentTrace, t as AgentType, w as CharacterBible, C as ChoiceCondition, j as CompensationConfig, D as DatabaseStepConfig, i as ErrorHandlingConfig, h as EventStepConfig, E as EventTrigger, o as ExecutionContext, r as ExecutionFilter, l as ExecutionStatus, P as GuardrailViolation, y as HandoffRule, H as HttpStepConfig, M as ManualTrigger, N as NotificationConfig, R as RetryConfig, u as RoleCategory, S as ScheduleTrigger, g as StepConfig, p as StepExecution, e as StepType, b as TriggerBase, n as TriggerData, T as TriggerType, c as WebhookTrigger, a as Workflow, k as WorkflowConfig, m as WorkflowExecution, q as WorkflowFilter, W as WorkflowStatus, f as WorkflowStep, d as WorkflowTrigger } from './agents-xcIn2dUB.js';
+export { AdminProvider } from '@mdxui/admin/components';
+import 'zod';
+import '@tanstack/react-query';
+import 'lucide-react';
+
+/**
+ * Type Definitions for DoAdmin
+ *
+ * Types for the embedded admin interface in @mdxui/do.
+ * Provides pre-configured admin components for .do platform.
+ *
+ * @module @mdxui/do/admin
+ */
+
+/**
+ * Base record type with ID
+ */
+interface DoRecord {
+    id: string | number;
+    [key: string]: unknown;
+}
+/**
+ * Extended DataProvider for DO-backed data operations.
+ * Adds DO-specific methods alongside standard CRUD operations.
+ */
+interface DoDataProvider {
+    getList: <T = DoRecord>(resource: string, params?: GetListParams) => Promise<GetListResult<T>>;
+    getOne: <T = DoRecord>(resource: string, params: GetOneParams) => Promise<GetOneResult<T>>;
+    getMany: <T = DoRecord>(resource: string, params: GetManyParams) => Promise<GetManyResult<T>>;
+    create: <T = DoRecord>(resource: string, params: CreateParams<T>) => Promise<CreateResult<T>>;
+    update: <T = DoRecord>(resource: string, params: UpdateParams<T>) => Promise<UpdateResult<T>>;
+    delete: <T = DoRecord>(resource: string, params: DeleteParams) => Promise<DeleteResult<T>>;
+    /**
+     * Get type statistics for a resource.
+     */
+    getTypeStats?: (resource: string) => Promise<{
+        total: number;
+        recentlyCreated: number;
+        recentlyUpdated: number;
+    }>;
+    /**
+     * Get version history for a record.
+     */
+    getVersions?: (resource: string, id: string) => Promise<unknown[]>;
+    /**
+     * Restore a record to a previous version.
+     */
+    restoreVersion?: (resource: string, id: string, version: number) => Promise<void>;
+}
+/**
+ * User identity from DO auth context
+ */
+interface DoUserIdentity {
+    /** Unique user ID */
+    id: string;
+    /** User's full name */
+    fullName?: string;
+    /** User's email */
+    email?: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Namespace/tenant the user belongs to */
+    namespace?: string;
+    /** User's role */
+    role?: string;
+    /** Additional claims/attributes */
+    claims?: Record<string, unknown>;
+}
+/**
+ * Login parameters for DO auth
+ */
+interface DoLoginParams {
+    /** Username or email */
+    username?: string;
+    /** Password */
+    password?: string;
+    /** API key (alternative to username/password) */
+    apiKey?: string;
+    /** OAuth token (for OAuth flows) */
+    oauthToken?: string;
+    /** Provider for OAuth (e.g., 'google', 'github') */
+    provider?: string;
+}
+/**
+ * DO Auth Provider interface
+ */
+interface DoAuthProvider {
+    /** Login with credentials */
+    login: (params: DoLoginParams) => Promise<void>;
+    /** Logout current session */
+    logout: () => Promise<void>;
+    /** Check if user is authenticated */
+    checkAuth: () => Promise<void>;
+    /** Check if an error is an auth error (401, 403) */
+    checkError: (error: Error) => Promise<void>;
+    /** Get current user identity */
+    getIdentity: () => Promise<DoUserIdentity>;
+    /** Get user permissions */
+    getPermissions: () => Promise<string[]>;
+}
+/**
+ * Resource definition for auto-generated CRUD views
+ */
+interface DoResourceDefinition {
+    /** Resource name (e.g., 'Task', 'User') */
+    name: string;
+    /** Display label (defaults to name) */
+    label?: string;
+    /** Icon component */
+    icon?: ReactNode;
+    /** Whether to show in sidebar */
+    showInSidebar?: boolean;
+    /** Custom list component (overrides auto-generated) */
+    list?: ComponentType;
+    /** Custom create component */
+    create?: ComponentType;
+    /** Custom edit component */
+    edit?: ComponentType;
+    /** Custom show component */
+    show?: ComponentType;
+    /** Field definitions for auto-generated views */
+    fields?: DoFieldDefinition[];
+    /** Filter definitions for list view */
+    filters?: DoFilterDefinition[];
+    /** Default sort for list view */
+    defaultSort?: ThingSort;
+    /** Records per page */
+    perPage?: number;
+}
+/**
+ * Field definition for auto-generated forms and displays
+ */
+interface DoFieldDefinition {
+    /** Field name/key */
+    name: string;
+    /** Display label */
+    label?: string;
+    /** Field type (determines input/display component) */
+    type: DoFieldType;
+    /** Whether field is required */
+    required?: boolean;
+    /** Whether field is read-only */
+    readOnly?: boolean;
+    /** Whether to show in list view */
+    showInList?: boolean;
+    /** Whether to show in create/edit forms */
+    showInForm?: boolean;
+    /** Whether to show in detail view */
+    showInDetail?: boolean;
+    /** Column width in list view */
+    width?: number | string;
+    /** Reference resource (for reference fields) */
+    reference?: string;
+    /** Options for select fields */
+    choices?: Array<{
+        id: string | number;
+        name: string;
+    }>;
+    /** Validation rules */
+    validate?: DoValidationRule[];
+}
+/**
+ * Supported field types
+ */
+type DoFieldType = 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'url' | 'password' | 'textarea' | 'richtext' | 'select' | 'reference' | 'array' | 'json' | 'image' | 'file';
+/**
+ * Filter definition for list views
+ */
+interface DoFilterDefinition {
+    /** Field to filter on */
+    field: string;
+    /** Display label */
+    label?: string;
+    /** Filter type */
+    type: 'text' | 'select' | 'date' | 'daterange' | 'boolean' | 'number';
+    /** Options for select filter */
+    choices?: Array<{
+        id: string | number;
+        name: string;
+    }>;
+    /** Default value */
+    defaultValue?: unknown;
+}
+/**
+ * Validation rule
+ */
+interface DoValidationRule {
+    /** Rule type */
+    type: 'required' | 'email' | 'url' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'custom';
+    /** Value for the rule (e.g., min value, pattern) */
+    value?: unknown;
+    /** Error message */
+    message?: string;
+}
+/**
+ * Configuration for DoAdmin component
+ */
+interface DoAdminConfig {
+    /** Admin title */
+    title?: string;
+    /** Logo element */
+    logo?: ReactNode;
+    /** Theme preference */
+    theme?: 'light' | 'dark' | 'system';
+    /** Base path for admin routes */
+    basePath?: string;
+    /** DO configuration */
+    doConfig: DOAdminConfig;
+    /** Resource definitions */
+    resources?: DoResourceDefinition[];
+    /** Whether to auto-discover resources from DO schema */
+    autoDiscoverResources?: boolean;
+    /** Dashboard component */
+    dashboard?: ReactNode;
+    /** Login page component */
+    loginPage?: ReactNode;
+    /** 404 page component */
+    notFoundPage?: ReactNode;
+    /** Custom layout component */
+    layout?: ComponentType<{
+        children: ReactNode;
+    }>;
+    /** Sidebar footer content */
+    sidebarFooter?: ReactNode;
+    /** Whether to disable built-in router (for external router integration) */
+    disableRouter?: boolean;
+}
+/**
+ * Result type for useDoAdmin hook
+ */
+interface UseDoAdminResult {
+    /** Current user identity */
+    user: DoUserIdentity | null;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Whether auth is loading */
+    isAuthLoading: boolean;
+    /** Whether connected to DO backend */
+    isConnected: boolean;
+    /** Connection error if any */
+    connectionError: Error | null;
+    /** Available resources */
+    resources: DoResourceDefinition[];
+    /** Current namespace */
+    namespace: string;
+    /** Set namespace */
+    setNamespace: (ns: string) => void;
+    /** Login function - accepts any params with index signature */
+    login: (params: Record<string, unknown>) => Promise<void>;
+    /** Logout function */
+    logout: () => Promise<void>;
+}
+
+interface DoAdminProps {
+    /** Admin configuration */
+    config: DoAdminConfig;
+    /** Children (additional content) */
+    children?: React.ReactNode;
+}
+/**
+ * DoAdmin - Full-featured admin interface for .do platform
+ *
+ * Provides a complete admin dashboard with:
+ * - Pre-configured DO data provider
+ * - Pre-configured DO auth provider
+ * - Auto-generated CRUD views for resources
+ * - Sidebar navigation
+ * - User authentication
+ *
+ * @example
+ * ```tsx
+ * import { DoAdmin } from '@mdxui/do'
+ *
+ * function App() {
+ *   return (
+ *     <DoAdmin
+ *       config={{
+ *         title: 'My Admin',
+ *         doConfig: {
+ *           apiEndpoint: 'https://api.example.do',
+ *           authMethod: 'jwt',
+ *           bindings: [],
+ *           realTimeUpdates: true,
+ *         },
+ *         resources: [
+ *           { name: 'Task', label: 'Tasks' },
+ *           { name: 'User', label: 'Users' },
+ *         ],
+ *       }}
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Minimal setup - auto-discovers resources
+ * <DoAdmin
+ *   config={{
+ *     doConfig: {
+ *       apiEndpoint: 'https://api.example.do',
+ *       authMethod: 'jwt',
+ *       bindings: [],
+ *       realTimeUpdates: true,
+ *     },
+ *     autoDiscoverResources: true,
+ *   }}
+ * />
+ * ```
+ */
+declare function DoAdmin({ config, children }: DoAdminProps): react_jsx_runtime.JSX.Element;
+declare namespace DoAdmin {
+    var displayName: string;
+}
+/**
+ * useDoAdmin - Hook to access DO admin context
+ *
+ * Provides access to user identity, auth state, resources, and namespace.
+ * Must be used within a DoAdmin component.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const {
+ *     user,
+ *     isAuthenticated,
+ *     namespace,
+ *     setNamespace,
+ *     logout,
+ *   } = useDoAdmin()
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {user?.fullName}</p>
+ *       <button onClick={logout}>Logout</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useDoAdmin(): UseDoAdminResult;
+
+/**
+ * Resource Discovery Utility
+ *
+ * Auto-generates resource definitions from DO configuration.
+ * Used by DoAdmin to build navigation and CRUD views automatically.
+ *
+ * @module @mdxui/do/admin
+ */
+
+/**
+ * Default resource types when no bindings or explicit resources are provided.
+ * These are the core entity types in the .do platform.
+ */
+declare const DEFAULT_RESOURCE_TYPES: readonly ["Thing", "Agent", "Workflow"];
+/**
+ * Discover resources from configuration.
+ *
+ * Priority order:
+ * 1. Explicitly provided resources (config.resources)
+ * 2. Auto-discovered from bindings (if autoDiscoverResources is true)
+ * 3. Default resources (Thing, Agent, Workflow)
+ *
+ * @param config - DoAdmin configuration
+ * @returns Array of resource definitions
+ *
+ * @example
+ * ```tsx
+ * // Explicit resources take priority
+ * const resources = discoverResources({
+ *   doConfig: { ... },
+ *   resources: [{ name: 'Task', label: 'Tasks' }],
+ * })
+ * // => [{ name: 'Task', label: 'Tasks' }]
+ *
+ * // Auto-discover from bindings
+ * const resources = discoverResources({
+ *   doConfig: {
+ *     bindings: [
+ *       { name: 'THINGS', className: 'ThingsRelationshipsDO' },
+ *     ],
+ *   },
+ *   autoDiscoverResources: true,
+ * })
+ * // => [{ name: 'Thing', label: 'Things', showInSidebar: true }]
+ *
+ * // Default resources when nothing specified
+ * const resources = discoverResources({
+ *   doConfig: { bindings: [] },
+ * })
+ * // => [{ name: 'Thing', ... }, { name: 'Agent', ... }, { name: 'Workflow', ... }]
+ * ```
+ */
+declare function discoverResources(config: DoAdminConfig): DoResourceDefinition[];
+/**
+ * Merge discovered resources with explicit overrides.
+ *
+ * This allows users to provide partial resource definitions that override
+ * discovered defaults while keeping the auto-discovery behavior.
+ *
+ * @param discovered - Auto-discovered resources
+ * @param overrides - User-provided resource overrides (by name)
+ * @returns Merged resources with overrides applied
+ */
+declare function mergeResourceOverrides(discovered: DoResourceDefinition[], overrides: Partial<DoResourceDefinition>[]): DoResourceDefinition[];
+
+/**
+ * Create a DataProvider that uses DO Things API.
+ *
+ * This factory function creates a DataProvider implementation that:
+ * - Maps resources to DO Thing types
+ * - Translates CRUD operations to DO API calls
+ * - Supports both REST and RPC modes based on DOProvider config
+ *
+ * @param apiEndpoint - Base API endpoint
+ * @param authToken - Optional auth token
+ * @param namespace - Default namespace
+ * @param rpcUrl - RPC endpoint for TanStack DB mode
+ */
+declare function createDoDataProvider(apiEndpoint: string, authToken?: string, namespace?: string, rpcUrl?: string | null): DoDataProvider;
+interface DoDataProviderProviderProps {
+    /** Children to render */
+    children: React.ReactNode;
+    /** Optional pre-created data provider */
+    dataProvider?: DoDataProvider;
+}
+/**
+ * DoDataProviderProvider
+ *
+ * A provider component that automatically creates and provides a DO-backed
+ * DataProvider using the current DOProvider context.
+ *
+ * @example
+ * ```tsx
+ * <DOProvider config={doConfig}>
+ *   <DoDataProviderProvider>
+ *     <MyApp />
+ *   </DoDataProviderProvider>
+ * </DOProvider>
+ * ```
+ */
+declare function DoDataProviderProvider({ children, dataProvider: providedDataProvider, }: DoDataProviderProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Create an AuthProvider that uses DO authentication API.
+ *
+ * @param apiEndpoint - Base API endpoint
+ * @param authMethod - Authentication method (jwt, api-key, oauth)
+ * @param authToken - Optional pre-existing auth token
+ * @param namespace - Default namespace
+ */
+declare function createDoAuthProvider(apiEndpoint: string, authMethod: 'jwt' | 'api-key' | 'oauth', authToken?: string, namespace?: string): DoAuthProvider;
+interface DoAuthProviderProviderProps {
+    /** Children to render */
+    children: React.ReactNode;
+    /** Optional pre-created auth provider */
+    authProvider?: DoAuthProvider;
+}
+/**
+ * DoAuthProviderProvider
+ *
+ * A provider component that automatically creates and provides a DO-backed
+ * AuthProvider using the current DOProvider context.
+ *
+ * @example
+ * ```tsx
+ * <DOProvider config={doConfig}>
+ *   <DoAuthProviderProvider>
+ *     <MyApp />
+ *   </DoAuthProviderProvider>
+ * </DOProvider>
+ * ```
+ */
+declare function DoAuthProviderProvider({ children, authProvider: providedAuthProvider, }: DoAuthProviderProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Merge class names with Tailwind CSS support
+ */
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Format a semantic ID (ns/type/id)
+ */
+declare function formatSemanticId(ns: string, type: string, id: string): string;
+/**
+ * Parse a semantic ID into components
+ * Format: type/namespace/id where namespace can contain slashes
+ * @throws Error if the semantic ID format is invalid
+ */
+declare function parseSemanticId(semanticId: string): {
+    type: string;
+    namespace: string;
+    id: string;
+};
+/**
+ * Format a date for display
+ */
+declare function formatDate(date: Date | string, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * Format a date and time for display
+ */
+declare function formatDateTime(date: Date | string, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * Format a relative time (e.g., "2 hours ago")
+ */
+declare function formatRelativeTime(date: Date | string): string;
+/**
+ * Format a number with abbreviation (1K, 1M, etc.)
+ */
+declare function formatNumber(num: number): string;
+/**
+ * Format bytes to human-readable string
+ */
+declare function formatBytes(bytes: number): string;
+/**
+ * Format duration in milliseconds to human-readable string
+ */
+declare function formatDuration(ms: number): string;
+/**
+ * Truncate text with ellipsis
+ */
+declare function truncate(text: string, maxLength: number, suffix?: string): string;
+/**
+ * Capitalize first letter
+ */
+declare function capitalize(text: string): string;
+/**
+ * Convert camelCase to Title Case
+ */
+declare function camelToTitle(text: string): string;
+/**
+ * Generate a random ID
+ */
+declare function generateId(prefix?: string): string;
+/**
+ * Debounce function
+ *
+ * Creates a debounced version of the function that delays execution
+ * until after the specified delay has passed since the last call.
+ *
+ * @example
+ * ```ts
+ * const debouncedSearch = debounce((query: string) => {
+ *   fetch(`/search?q=${query}`)
+ * }, 300)
+ *
+ * // Only the last call within 300ms will execute
+ * debouncedSearch('h')
+ * debouncedSearch('he')
+ * debouncedSearch('hello') // Only this one runs
+ * ```
+ */
+declare function debounce<Args extends unknown[]>(fn: (...args: Args) => unknown, delay: number): (...args: Args) => void;
+/**
+ * Group array by key
+ */
+declare function groupBy<T, K extends string | number>(array: T[], keyFn: (item: T) => K): Record<K, T[]>;
+
+/**
+ * Extended RequestInit that includes optional timeout
+ */
+interface FetchWithTimeoutOptions extends RequestInit {
+    /** Timeout in milliseconds. Defaults to 30000 (30 seconds) */
+    timeout?: number;
+}
+/**
+ * Fetch wrapper with configurable timeout
+ *
+ * Uses AbortController to cancel requests that exceed the timeout.
+ * If the request already has a signal, a composite abort will be used
+ * that respects both the existing signal and the timeout.
+ *
+ * @param url - The URL to fetch
+ * @param options - Fetch options including optional timeout
+ * @returns Promise resolving to the Response
+ * @throws {DOMException} AbortError if the request times out
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with default 30s timeout
+ * const response = await fetchWithTimeout('https://api.example.com/data')
+ *
+ * // Custom timeout
+ * const response = await fetchWithTimeout('https://api.example.com/data', {
+ *   timeout: 5000, // 5 seconds
+ * })
+ *
+ * // With other fetch options
+ * const response = await fetchWithTimeout('https://api.example.com/data', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ key: 'value' }),
+ *   timeout: 10000,
+ * })
+ * ```
+ */
+declare function fetchWithTimeout(url: string, options?: FetchWithTimeoutOptions): Promise<Response>;
+
+/**
+ * Standardized error classes for @mdxui/do
+ *
+ * These classes provide consistent error handling across the package:
+ * - APIError: HTTP/RPC errors from the backend
+ * - NetworkError: Connection/fetch failures
+ * - ValidationError: Input validation errors
+ * - SyncError: Real-time sync errors
+ *
+ * @example
+ * ```typescript
+ * import { APIError, NetworkError, isAPIError } from '@mdxui/do'
+ *
+ * try {
+ *   const response = await fetch(url)
+ *   if (!response.ok) {
+ *     throw APIError.fromResponse(response)
+ *   }
+ * } catch (error) {
+ *   if (isAPIError(error)) {
+ *     console.log(`API error ${error.code}: ${error.message}`)
+ *     if (error.status === 401) {
+ *       // Handle auth error
+ *     }
+ *   } else if (isNetworkError(error)) {
+ *     console.log('Network unavailable, will retry...')
+ *   }
+ * }
+ * ```
+ */
+/**
+ * API error from HTTP/RPC calls
+ *
+ * Provides structured error information including:
+ * - code: Machine-readable error code (e.g., 'HTTP_404', 'VALIDATION_ERROR')
+ * - message: Human-readable error message
+ * - status: HTTP status code (when applicable)
+ * - details: Additional error details from the server
+ */
+declare class APIError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, status?: number | undefined, details?: Record<string, unknown> | undefined);
+    /**
+     * Create an APIError from a fetch Response
+     *
+     * @param response - The Response object from fetch
+     * @param body - Optional response body text (if already read)
+     * @returns An APIError with HTTP status information
+     *
+     * @example
+     * ```typescript
+     * const response = await fetch('/api/things')
+     * if (!response.ok) {
+     *   throw APIError.fromResponse(response, await response.text())
+     * }
+     * ```
+     */
+    static fromResponse(response: Response, body?: string): APIError;
+    /**
+     * Type guard to check if an error is an APIError
+     */
+    static isAPIError(error: unknown): error is APIError;
+}
+/**
+ * Network-level error (connection failures, timeouts, etc.)
+ *
+ * Use for errors that occur before an HTTP response is received:
+ * - DNS resolution failures
+ * - Connection refused
+ * - Request timeouts
+ * - CORS errors
+ */
+declare class NetworkError extends Error {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Validation error with field-level details
+ *
+ * Use when input data fails validation checks.
+ * The fields property maps field names to arrays of error messages.
+ *
+ * @example
+ * ```typescript
+ * throw new ValidationError('Invalid input', {
+ *   email: ['Invalid email format'],
+ *   name: ['Name is required', 'Name must be at least 2 characters'],
+ * })
+ * ```
+ */
+declare class ValidationError extends Error {
+    readonly fields: Record<string, string[]>;
+    constructor(message: string, fields: Record<string, string[]>);
+}
+/**
+ * Real-time sync error
+ *
+ * Use for errors in the sync protocol (WebSocket, EventSource, etc.).
+ * The operation property indicates what sync operation failed.
+ * The recoverable property indicates whether the client should retry.
+ *
+ * @example
+ * ```typescript
+ * // Recoverable connection error - client should retry
+ * throw new SyncError('WebSocket disconnected', 'connect', true)
+ *
+ * // Non-recoverable push error - user intervention needed
+ * throw new SyncError('Conflict: record modified by another user', 'push', false)
+ * ```
+ */
+declare class SyncError extends Error {
+    readonly operation: 'push' | 'pull' | 'connect';
+    readonly recoverable: boolean;
+    constructor(message: string, operation: 'push' | 'pull' | 'connect', recoverable: boolean);
+}
+/**
+ * Type guard to check if an error is an APIError
+ */
+declare function isAPIError(error: unknown): error is APIError;
+/**
+ * Type guard to check if an error is a NetworkError
+ */
+declare function isNetworkError(error: unknown): error is NetworkError;
+/**
+ * Type guard to check if an error is a ValidationError
+ */
+declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Type guard to check if an error is a SyncError
+ */
+declare function isSyncError(error: unknown): error is SyncError;
+
+/**
+ * Typed RPC client for @mdxui/do
+ *
+ * Provides a unified interface for making RPC calls to the .do backend,
+ * with consistent error handling, timeouts, and authentication.
+ *
+ * @example
+ * ```typescript
+ * // Create a client
+ * const client = createRPCClient({
+ *   rpcUrl: 'https://api.do/rpc',
+ *   authToken: 'xxx',
+ *   timeout: 5000,
+ * })
+ *
+ * // Make typed RPC calls
+ * const things = await client.call<ListInput, Thing[]>('things.list', { limit: 10 })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use the hook in a component
+ * function MyComponent() {
+ *   const client = useRPCClient()
+ *
+ *   if (!client) {
+ *     return <div>RPC not available (REST mode)</div>
+ *   }
+ *
+ *   // Use client...
+ * }
+ * ```
+ *
+ * @module
+ */
+/**
+ * Configuration for creating an RPC client
+ */
+interface RPCClientConfig {
+    /** Base RPC URL (e.g., 'https://api.do/rpc') */
+    rpcUrl: string;
+    /** Optional auth token for Bearer authentication */
+    authToken?: string;
+    /** Request timeout in milliseconds (defaults to 30000) */
+    timeout?: number;
+}
+/**
+ * Options for an individual RPC call
+ */
+interface RPCCallOptions {
+    /** AbortSignal for cancelling the request mid-flight */
+    signal?: AbortSignal;
+}
+/**
+ * Typed RPC client interface
+ */
+interface RPCClient {
+    /**
+     * Make a typed RPC call
+     *
+     * @param method - The RPC method name (e.g., 'things.list', 'things.get')
+     * @param input - The input payload for the RPC method
+     * @param options - Optional call options including AbortSignal
+     * @returns Promise resolving to the typed output
+     * @throws {APIError} If the server returns a non-OK response
+     * @throws {NetworkError} If the network request fails
+     * @throws {DOMException} AbortError if the request is cancelled via signal
+     */
+    call<TInput, TOutput>(method: string, input: TInput, options?: RPCCallOptions): Promise<TOutput>;
+}
+/**
+ * Create a typed RPC client
+ *
+ * @param config - Client configuration
+ * @returns An RPC client instance
+ *
+ * @example
+ * ```typescript
+ * const client = createRPCClient({
+ *   rpcUrl: 'https://api.do/rpc',
+ *   authToken: 'jwt-token',
+ *   timeout: 10000,
+ * })
+ *
+ * // List things
+ * const things = await client.call<{ limit: number }, Thing[]>('things.list', { limit: 10 })
+ *
+ * // Get a single thing
+ * const thing = await client.call<{ id: string }, Thing>('things.get', { id: 'thing-123' })
+ *
+ * // Create a thing
+ * const newThing = await client.call<CreateInput, Thing>('things.create', { name: 'New Thing' })
+ *
+ * // With AbortSignal for cancellation
+ * const controller = new AbortController()
+ * const things = await client.call<{ limit: number }, Thing[]>(
+ *   'things.list',
+ *   { limit: 10 },
+ *   { signal: controller.signal }
+ * )
+ * // To cancel: controller.abort()
+ * ```
+ */
+declare function createRPCClient(config: RPCClientConfig): RPCClient;
+/**
+ * Hook to access an RPC client from the DO context
+ *
+ * Returns null when not in TanStack DB mode (i.e., when doUrl is not configured).
+ * The client is memoized and only recreated when the rpcUrl, authToken, or
+ * requestTimeout changes.
+ *
+ * @returns An RPC client instance, or null if RPC is not available
+ *
+ * @example
+ * ```typescript
+ * function ThingsList() {
+ *   const client = useRPCClient()
+ *   const [things, setThings] = useState<Thing[]>([])
+ *
+ *   useEffect(() => {
+ *     if (!client) return
+ *
+ *     client.call<{ limit: number }, Thing[]>('things.list', { limit: 10 })
+ *       .then(setThings)
+ *       .catch(console.error)
+ *   }, [client])
+ *
+ *   if (!client) {
+ *     return <div>RPC not available</div>
+ *   }
+ *
+ *   return <ul>{things.map(t => <li key={t.id}>{t.name}</li>)}</ul>
+ * }
+ * ```
+ */
+declare function useRPCClient(): RPCClient | null;
+
+/**
+ * Batch sync utilities for optimizing sync operations
+ *
+ * Batches rapid changes to reduce sync overhead and improve performance.
+ * Instead of syncing every mutation individually, changes are buffered
+ * and sent in batches.
+ *
+ * @module
+ */
+/**
+ * Options for batch sync operations
+ */
+interface BatchSyncOptions {
+    /** Maximum number of items before forcing a flush (default: 100) */
+    maxBatchSize?: number;
+    /** Maximum time to wait before flushing in ms (default: 50) */
+    maxWaitMs?: number;
+}
+/**
+ * Return type for batched operations controller
+ */
+interface BatchedOperations<T> {
+    /** Add an item to the batch queue */
+    add: (item: T) => void;
+    /** Force flush all pending items immediately */
+    flush: () => Promise<void>;
+    /** Get the current number of pending items */
+    readonly pending: number;
+}
+/**
+ * Create a batched operations controller
+ *
+ * Buffers items and executes them in batches to reduce overhead.
+ * Items are flushed when either:
+ * - The batch reaches maxBatchSize
+ * - maxWaitMs has elapsed since the first item was added
+ *
+ * @param executor - Function to execute with batched items
+ * @param options - Batch configuration options
+ * @returns Controller for managing batched operations
+ *
+ * @example
+ * ```typescript
+ * const batchedSync = createBatchedOperations<Mutation>(
+ *   async (mutations) => {
+ *     await syncToServer(mutations)
+ *   },
+ *   { maxBatchSize: 50, maxWaitMs: 100 }
+ * )
+ *
+ * // These will be batched together
+ * batchedSync.add({ type: 'create', data: { name: 'A' } })
+ * batchedSync.add({ type: 'create', data: { name: 'B' } })
+ * batchedSync.add({ type: 'create', data: { name: 'C' } })
+ *
+ * // Force immediate flush if needed
+ * await batchedSync.flush()
+ * ```
+ */
+declare function createBatchedOperations<T>(executor: (items: T[]) => Promise<void>, options?: BatchSyncOptions): BatchedOperations<T>;
+
+/**
+ * Offline queue for mutation persistence during disconnection
+ *
+ * Queues mutations when offline and persists them to localStorage
+ * for replay when connection is restored.
+ *
+ * @module
+ */
+/**
+ * Options for offline queue
+ */
+interface OfflineQueueOptions {
+    /** Maximum number of items to queue (default: 1000) */
+    maxQueueSize?: number;
+    /** LocalStorage key for persistence (optional) */
+    persistKey?: string;
+}
+/**
+ * Offline queue controller interface
+ */
+interface OfflineQueue<T> {
+    /** Add an item to the queue. Returns false if queue is full. */
+    enqueue: (item: T) => boolean;
+    /** Remove and return all queued items */
+    dequeueAll: () => T[];
+    /** Peek at all items without removing */
+    peek: () => readonly T[];
+    /** Clear all items from the queue */
+    clear: () => void;
+    /** Current number of items in queue */
+    readonly length: number;
+    /** Whether queue is at capacity */
+    readonly isFull: boolean;
+}
+/**
+ * Create an offline queue for mutation persistence
+ *
+ * Queues items during offline periods and can persist to localStorage
+ * for durability across page refreshes.
+ *
+ * @param options - Queue configuration options
+ * @returns Offline queue controller
+ *
+ * @example
+ * ```typescript
+ * const queue = createOfflineQueue<Mutation>({
+ *   maxQueueSize: 500,
+ *   persistKey: 'my-app-offline-mutations'
+ * })
+ *
+ * // Queue mutations when offline
+ * if (!navigator.onLine) {
+ *   queue.enqueue({ type: 'create', data: { name: 'Test' } })
+ * }
+ *
+ * // Replay when back online
+ * window.addEventListener('online', async () => {
+ *   const mutations = queue.dequeueAll()
+ *   await syncMutations(mutations)
+ * })
+ * ```
+ */
+declare function createOfflineQueue<T>(options?: OfflineQueueOptions): OfflineQueue<T>;
+
+export { APIError, type BatchSyncOptions, type BatchedOperations, DEFAULT_RESOURCE_TYPES, DOAdminConfig, DoAdmin, type DoAdminConfig, type DoAdminProps, type DoAuthProvider, DoAuthProviderProvider, type DoAuthProviderProviderProps, type DoDataProvider, DoDataProviderProvider, type DoDataProviderProviderProps, type DoFieldDefinition, type DoFieldType, type DoFilterDefinition, type DoLoginParams, type DoRecord, type DoResourceDefinition, type DoUserIdentity, type DoValidationRule, type FetchWithTimeoutOptions, NetworkError, type OfflineQueue, type OfflineQueueOptions, type RPCCallOptions, type RPCClient, type RPCClientConfig, SyncError, ThingSort, type UseDoAdminResult, ValidationError, camelToTitle, capitalize, cn, createBatchedOperations, createDoAuthProvider, createDoDataProvider, createOfflineQueue, createRPCClient, debounce, discoverResources, fetchWithTimeout, formatBytes, formatDate, formatDateTime, formatDuration, formatNumber, formatRelativeTime, formatSemanticId, generateId, groupBy, isAPIError, isNetworkError, isSyncError, isValidationError, mergeResourceOverrides, parseSemanticId, truncate, useDoAdmin, useRPCClient };