@mdxui/do 2.1.1

package/dist/hooks/index.d.ts

@@ -0,0 +1,801 @@
+import { a as ThingQueryResult, T as Thing, j as ThingVersion, k as TypeStats, b as ThingCreateInput, h as ThingUpdateInput, c as ThingFilter, d as ThingSort, e as ThingPagination } from '../thing-DtI25yZh.js';
+import { QueryObserverResult, UseQueryResult, UseMutationResult } from '@tanstack/react-query';
+import * as zod from 'zod';
+import { EntityReference } from '../schemas/index.js';
+import { RelationshipFilter, GraphPattern, Relationship, GraphTraversalResult, GraphStats, RelationshipCreateInput, PaginatedResult } from '../types/index.js';
+import { q as WorkflowFilter, r as ExecutionFilter, U as AgentFilter, V as AgentExecutionFilter, a as Workflow, m as WorkflowExecution, s as Agent, B as AgentMetrics, F as AgentExecution, Q as AgentFeedback } from '../agents-xcIn2dUB.js';
+import * as React from 'react';
+import { DataProvider, DotdoDataProviderConfig, UseResourceConfig, UseResourceResult } from '@dotdo/react/admin';
+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';
+import { AdminProviderProps } from '@mdxui/admin/components';
+export { AdminProvider } from '@mdxui/admin/components';
+export { WorkflowContext, use$ } from '@dotdo/react';
+import '../do-CaQVueZw.js';
+
+/**
+ * Type definitions for Things hooks
+ *
+ * Provides return types for query and mutation hooks.
+ */
+
+/**
+ * Return type for useThings hook
+ */
+interface UseThingsResult {
+    /** The query result data, or null if not yet loaded */
+    data: ThingQueryResult | null;
+    /** True during initial load */
+    isLoading: boolean;
+    /** Error from the query, or null */
+    error: Error | null;
+    /** Function to manually refetch the data */
+    refetch: () => Promise<QueryObserverResult<ThingQueryResult, Error>>;
+    /** The query key used for cache management */
+    queryKey: readonly unknown[];
+    /** True if refetching in the background */
+    isRefetching: boolean;
+    /** True if any fetch is in progress */
+    isFetching: boolean;
+    /** Query status: 'pending', 'success', or 'error' */
+    status: 'pending' | 'success' | 'error';
+}
+/**
+ * Return type for useThing hook
+ */
+interface UseThingResult {
+    /** The Thing data, or null if not yet loaded */
+    data: Thing | null;
+    /** True during initial load */
+    isLoading: boolean;
+    /** Error from the query, or null */
+    error: Error | null;
+    /** Function to manually refetch the data */
+    refetch: () => Promise<QueryObserverResult<Thing, Error>>;
+    /** The query key used for cache management */
+    queryKey: readonly unknown[];
+    /** True if refetching in the background */
+    isRefetching: boolean;
+    /** True if any fetch is in progress */
+    isFetching: boolean;
+    /** Query status: 'pending', 'success', or 'error' */
+    status: 'pending' | 'success' | 'error';
+}
+/**
+ * Return type for useThingVersions hook
+ */
+interface UseThingVersionsResult {
+    /** The versions array, or null if not yet loaded */
+    data: ThingVersion[] | null;
+    /** True during initial load */
+    isLoading: boolean;
+    /** Error from the query, or null */
+    error: Error | null;
+    /** Function to manually refetch the data */
+    refetch: () => Promise<QueryObserverResult<ThingVersion[], Error>>;
+    /** The query key used for cache management */
+    queryKey: readonly unknown[];
+    /** True if refetching in the background */
+    isRefetching: boolean;
+    /** True if any fetch is in progress */
+    isFetching: boolean;
+    /** Query status: 'pending', 'success', or 'error' */
+    status: 'pending' | 'success' | 'error';
+}
+/**
+ * Return type for useTypeStats hook
+ */
+interface UseTypeStatsResult {
+    /** The type statistics, or null if not yet loaded */
+    data: TypeStats | null;
+    /** True during initial load */
+    isLoading: boolean;
+    /** Error from the query, or null */
+    error: Error | null;
+    /** Function to manually refetch the data */
+    refetch: () => Promise<QueryObserverResult<TypeStats, Error>>;
+    /** The query key used for cache management */
+    queryKey: readonly unknown[];
+    /** True if refetching in the background */
+    isRefetching: boolean;
+    /** True if any fetch is in progress */
+    isFetching: boolean;
+    /** Query status: 'pending', 'success', or 'error' */
+    status: 'pending' | 'success' | 'error';
+}
+/**
+ * Return type for useCreateThing hook
+ */
+interface UseCreateThingResult {
+    /** Trigger the mutation */
+    mutate: (input: ThingCreateInput) => void;
+    /** Trigger the mutation and return a promise */
+    mutateAsync: (input: ThingCreateInput) => Promise<Thing>;
+    /** True while mutation is in progress */
+    isLoading: boolean;
+    /** Error from the mutation, or null */
+    error: Error | null;
+    /** True if the mutation succeeded */
+    isSuccess: boolean;
+    /** Reset the mutation state */
+    reset: () => void;
+}
+/**
+ * Return type for useUpdateThing hook
+ */
+interface UseUpdateThingResult {
+    /** Trigger the mutation */
+    mutate: (input: ThingUpdateInput) => void;
+    /** Trigger the mutation and return a promise */
+    mutateAsync: (input: ThingUpdateInput) => Promise<Thing>;
+    /** True while mutation is in progress */
+    isLoading: boolean;
+    /** Error from the mutation, or null */
+    error: Error | null;
+    /** True if the mutation succeeded */
+    isSuccess: boolean;
+    /** Reset the mutation state */
+    reset: () => void;
+}
+/**
+ * Options for delete operation
+ */
+interface DeleteThingOptions {
+    /** If true, permanently delete instead of soft delete */
+    hard?: boolean;
+}
+/**
+ * Return type for useDeleteThing hook
+ */
+interface UseDeleteThingResult {
+    /** Trigger the mutation */
+    mutate: (options?: DeleteThingOptions) => void;
+    /** Trigger the mutation and return a promise */
+    mutateAsync: (options?: DeleteThingOptions) => Promise<void>;
+    /** True while mutation is in progress */
+    isLoading: boolean;
+    /** Error from the mutation, or null */
+    error: Error | null;
+    /** True if the mutation succeeded */
+    isSuccess: boolean;
+    /** Reset the mutation state */
+    reset: () => void;
+}
+
+/**
+ * Hook to fetch a list of Things
+ *
+ * Uses two modes:
+ * - **TanStack DB mode**: Real-time sync via @dotdo/react useCollection
+ * - **REST/RPC mode**: React Query for caching with fetch or RPC calls
+ */
+declare function useThings(filter?: ThingFilter, sort?: ThingSort, pagination?: ThingPagination): UseThingsResult;
+/**
+ * Hook to fetch a single Thing
+ *
+ * Uses the useRPCClient hook for RPC calls instead of inline fetch,
+ * demonstrating the pattern for utilizing extracted utilities.
+ */
+declare function useThing(ns: string, type: string, id: string): UseThingResult;
+/**
+ * Hook to fetch Thing version history
+ */
+declare function useThingVersions(ns: string, type: string, id: string): UseThingVersionsResult;
+/**
+ * Hook to fetch type statistics
+ */
+declare function useTypeStats(ns: string, type: string): UseTypeStatsResult;
+
+/**
+ * Hook to create a Thing
+ *
+ * Automatically invalidates the things list cache on success.
+ *
+ * Supports three modes:
+ * 1. **DataProvider mode**: Uses DataProvider.create() when available (via DoDataProviderProvider)
+ * 2. **TanStack DB mode**: Uses RPC when doUrl is configured
+ * 3. **REST API mode**: Falls back to fetch-based API calls
+ */
+declare function useCreateThing(): UseCreateThingResult;
+/**
+ * Hook to update a Thing
+ *
+ * Automatically invalidates the related cache entries on success.
+ *
+ * Supports three modes:
+ * 1. **DataProvider mode**: Uses DataProvider.update() when available (via DoDataProviderProvider)
+ * 2. **TanStack DB mode**: Uses RPC when doUrl is configured
+ * 3. **REST API mode**: Falls back to fetch-based API calls
+ */
+declare function useUpdateThing(ns: string, type: string, id: string): UseUpdateThingResult;
+/**
+ * Hook to delete a Thing (soft delete by default)
+ *
+ * Automatically invalidates the related cache entries on success.
+ *
+ * Supports three modes:
+ * 1. **DataProvider mode**: Uses DataProvider.delete() when available (via DoDataProviderProvider)
+ * 2. **TanStack DB mode**: Uses RPC when doUrl is configured
+ * 3. **REST API mode**: Falls back to fetch-based API calls
+ *
+ * Note: DataProvider mode always performs soft delete. For hard delete,
+ * use RPC or REST API modes with `{ hard: true }` option.
+ */
+declare function useDeleteThing(ns: string, type: string, id: string): UseDeleteThingResult;
+
+/**
+ * Query keys for Things resource
+ *
+ * Things have a special key structure because:
+ * - List queries include filter, sort, and pagination
+ * - Detail queries use composite keys (ns, type, id) instead of a single id
+ * - Additional sub-queries for versions and type stats
+ */
+declare const thingsKeys: {
+    all: readonly ["things"];
+    lists: () => readonly ["things", "list"];
+    list: (filter: ThingFilter, sort?: ThingSort, pagination?: ThingPagination) => readonly ["things", "list", {
+        readonly filter: zod.objectOutputType<{
+            ns: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
+            type: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
+            idPattern: zod.ZodOptional<zod.ZodString>;
+            nameSearch: zod.ZodOptional<zod.ZodString>;
+            createdAfter: zod.ZodOptional<zod.ZodDate>;
+            createdBefore: zod.ZodOptional<zod.ZodDate>;
+            updatedAfter: zod.ZodOptional<zod.ZodDate>;
+            updatedBefore: zod.ZodOptional<zod.ZodDate>;
+            includeDeleted: zod.ZodOptional<zod.ZodBoolean>;
+            properties: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            variant: zod.ZodOptional<zod.ZodString>;
+        }, zod.ZodTypeAny, "passthrough">;
+        readonly sort: {
+            field: "type" | "name" | "ts" | "createdAt" | "updatedAt";
+            order: "asc" | "desc";
+        } | undefined;
+        readonly pagination: {
+            page: number;
+            perPage: number;
+        } | undefined;
+    }];
+    details: () => readonly ["things", "detail"];
+    detail: (ns: string, type: string, id: string) => readonly ["things", "detail", string, string, string];
+    versions: (ns: string, type: string, id: string) => readonly ["things", "detail", string, string, string, "versions"];
+    types: () => readonly ["things", "types"];
+    typeStats: (ns: string, type: string) => readonly ["things", "types", string, string];
+};
+/**
+ * Query keys for Agents resource
+ *
+ * Includes keys for:
+ * - Agent lists and details
+ * - Agent metrics (per-agent)
+ * - Agent executions (list and detail)
+ */
+declare const agentsKeys: {
+    all: readonly ["agents"];
+    lists: () => readonly ["agents", "list"];
+    list: (filter: AgentFilter) => readonly ["agents", "list", AgentFilter];
+    details: () => readonly ["agents", "detail"];
+    detail: (id: string) => readonly ["agents", "detail", string];
+    metrics: (id: string) => readonly ["agents", "detail", string, "metrics"];
+    executions: () => readonly ["agents", "executions"];
+    executionsList: (filter: AgentExecutionFilter) => readonly ["agents", "executions", "list", AgentExecutionFilter];
+    execution: (id: string) => readonly ["agents", "executions", "detail", string];
+};
+/**
+ * Query keys for Workflows resource
+ *
+ * Includes keys for:
+ * - Workflow lists and details
+ * - Workflow executions (list and detail)
+ */
+declare const workflowsKeys: {
+    all: readonly ["workflows"];
+    lists: () => readonly ["workflows", "list"];
+    list: (filter: WorkflowFilter) => readonly ["workflows", "list", WorkflowFilter];
+    details: () => readonly ["workflows", "detail"];
+    detail: (id: string) => readonly ["workflows", "detail", string];
+    executions: () => readonly ["workflows", "executions"];
+    executionsList: (filter: ExecutionFilter) => readonly ["workflows", "executions", "list", ExecutionFilter];
+    execution: (id: string) => readonly ["workflows", "executions", "detail", string];
+};
+/**
+ * Query keys for Relationships resource
+ *
+ * Includes keys for:
+ * - Relationship lists and details
+ * - Graph traversal queries
+ * - Graph statistics
+ */
+declare const relationshipsKeys: {
+    all: readonly ["relationships"];
+    lists: () => readonly ["relationships", "list"];
+    list: (filter: RelationshipFilter) => readonly ["relationships", "list", RelationshipFilter];
+    details: () => readonly ["relationships", "detail"];
+    detail: (id: string) => readonly ["relationships", "detail", string];
+    graph: () => readonly ["relationships", "graph"];
+    traverse: (entity: EntityReference, pattern: GraphPattern) => readonly ["relationships", "graph", {
+        type: string;
+        ns: string;
+        id: string;
+        semanticId: string;
+        name?: string | undefined;
+    }, GraphPattern];
+    stats: () => readonly ["relationships", "stats"];
+};
+
+/**
+ * Return type for useRelationships hook
+ */
+type UseRelationshipsResult = UseQueryResult<Relationship[], Error>;
+/**
+ * Result type for entity relationships containing both directions
+ */
+interface EntityRelationshipsData {
+    outgoing: Relationship[];
+    incoming: Relationship[];
+}
+/**
+ * Return type for useEntityRelationships hook
+ */
+type UseEntityRelationshipsResult = UseQueryResult<EntityRelationshipsData, Error>;
+/**
+ * Return type for useGraphTraversal hook
+ */
+type UseGraphTraversalResult = UseQueryResult<GraphTraversalResult, Error>;
+/**
+ * Return type for useGraphStats hook
+ */
+type UseGraphStatsResult = UseQueryResult<GraphStats, Error>;
+/**
+ * Return type for useCreateRelationship hook
+ */
+type UseCreateRelationshipResult = UseMutationResult<Relationship, Error, RelationshipCreateInput>;
+/**
+ * Return type for useDeleteRelationship hook
+ */
+type UseDeleteRelationshipResult = UseMutationResult<void, Error, string>;
+
+/**
+ * Hook to fetch relationships
+ */
+declare function useRelationships(filter?: RelationshipFilter): UseRelationshipsResult;
+/**
+ * Hook to fetch relationships for a specific entity
+ */
+declare function useEntityRelationships(entity: EntityReference, direction?: 'outgoing' | 'incoming' | 'both'): UseEntityRelationshipsResult;
+/**
+ * Hook to traverse the graph from a starting entity
+ */
+declare function useGraphTraversal(entity: EntityReference, pattern: GraphPattern): UseGraphTraversalResult;
+/**
+ * Hook to get graph statistics
+ */
+declare function useGraphStats(): UseGraphStatsResult;
+/**
+ * Hook to create a relationship
+ */
+declare function useCreateRelationship(): UseCreateRelationshipResult;
+/**
+ * Hook to delete a relationship
+ */
+declare function useDeleteRelationship(): UseDeleteRelationshipResult;
+
+/**
+ * Return type for useWorkflows hook
+ */
+type UseWorkflowsResult = UseQueryResult<PaginatedResult<Workflow>, Error>;
+/**
+ * Return type for useWorkflow hook
+ */
+type UseWorkflowResult = UseQueryResult<Workflow, Error>;
+/**
+ * Return type for useWorkflowExecutions hook
+ */
+type UseWorkflowExecutionsResult = UseQueryResult<PaginatedResult<WorkflowExecution>, Error>;
+/**
+ * Return type for useWorkflowExecution hook
+ */
+type UseWorkflowExecutionResult = UseQueryResult<WorkflowExecution, Error>;
+/**
+ * Return type for useCreateWorkflow hook
+ */
+type UseCreateWorkflowResult = UseMutationResult<Workflow, Error, Partial<Workflow>>;
+/**
+ * Return type for useUpdateWorkflow hook
+ */
+type UseUpdateWorkflowResult = UseMutationResult<Workflow, Error, Partial<Workflow>>;
+/**
+ * Return type for useTriggerWorkflow hook
+ */
+type UseTriggerWorkflowResult = UseMutationResult<WorkflowExecution, Error, Record<string, unknown> | undefined>;
+/**
+ * Return type for useCancelExecution hook
+ */
+type UseCancelExecutionResult = UseMutationResult<void, Error, string>;
+/**
+ * Return type for useDeleteWorkflow hook
+ */
+type UseDeleteWorkflowResult = UseMutationResult<void, Error, string>;
+
+/**
+ * Hook to fetch workflows
+ */
+declare function useWorkflows(filter?: WorkflowFilter): UseWorkflowsResult;
+/**
+ * Hook to fetch a single workflow
+ */
+declare function useWorkflow(id: string): UseWorkflowResult;
+/**
+ * Hook to fetch workflow executions
+ */
+declare function useWorkflowExecutions(filter?: ExecutionFilter): UseWorkflowExecutionsResult;
+/**
+ * Hook to fetch a single execution
+ */
+declare function useWorkflowExecution(id: string): UseWorkflowExecutionResult;
+/**
+ * Hook to create a workflow
+ */
+declare function useCreateWorkflow(): UseCreateWorkflowResult;
+/**
+ * Hook to update a workflow
+ */
+declare function useUpdateWorkflow(id: string): UseUpdateWorkflowResult;
+/**
+ * Hook to trigger a workflow manually
+ */
+declare function useTriggerWorkflow(id: string): UseTriggerWorkflowResult;
+/**
+ * Hook to cancel a workflow execution
+ */
+declare function useCancelExecution(): UseCancelExecutionResult;
+/**
+ * Hook to delete a workflow
+ */
+declare function useDeleteWorkflow(): UseDeleteWorkflowResult;
+
+/**
+ * Return type for useAgents hook
+ */
+type UseAgentsResult = UseQueryResult<PaginatedResult<Agent>, Error>;
+/**
+ * Return type for useAgent hook
+ */
+type UseAgentResult = UseQueryResult<Agent, Error>;
+/**
+ * Return type for useAgentMetrics hook
+ */
+type UseAgentMetricsResult = UseQueryResult<AgentMetrics, Error>;
+/**
+ * Return type for useAgentExecutions hook
+ */
+type UseAgentExecutionsResult = UseQueryResult<PaginatedResult<AgentExecution>, Error>;
+/**
+ * Return type for useAgentExecution hook
+ */
+type UseAgentExecutionResult = UseQueryResult<AgentExecution, Error>;
+/**
+ * Return type for useCreateAgent hook
+ */
+type UseCreateAgentResult = UseMutationResult<Agent, Error, Partial<Agent>>;
+/**
+ * Return type for useUpdateAgent hook
+ */
+type UseUpdateAgentResult = UseMutationResult<Agent, Error, Partial<Agent>>;
+/**
+ * Input type for useExecuteAgent mutation
+ */
+interface ExecuteAgentInput {
+    task: string;
+    context?: Record<string, unknown>;
+}
+/**
+ * Return type for useExecuteAgent hook
+ */
+type UseExecuteAgentResult = UseMutationResult<AgentExecution, Error, ExecuteAgentInput>;
+/**
+ * Input type for useSubmitAgentFeedback mutation
+ */
+type SubmitAgentFeedbackInput = Omit<AgentFeedback, 'submittedAt' | 'submittedBy'>;
+/**
+ * Return type for useSubmitAgentFeedback hook
+ */
+type UseSubmitAgentFeedbackResult = UseMutationResult<void, Error, SubmitAgentFeedbackInput>;
+/**
+ * Return type for useDeleteAgent hook
+ */
+type UseDeleteAgentResult = UseMutationResult<void, Error, string>;
+
+/**
+ * Hook to fetch agents
+ */
+declare function useAgents(filter?: AgentFilter): UseAgentsResult;
+/**
+ * Hook to fetch a single agent
+ */
+declare function useAgent(id: string): UseAgentResult;
+/**
+ * Hook to fetch agent metrics
+ */
+declare function useAgentMetrics(id: string, periodDays?: number): UseAgentMetricsResult;
+/**
+ * Hook to fetch agent executions
+ */
+declare function useAgentExecutions(filter?: AgentExecutionFilter): UseAgentExecutionsResult;
+/**
+ * Hook to fetch a single agent execution
+ */
+declare function useAgentExecution(id: string): UseAgentExecutionResult;
+/**
+ * Hook to create an agent
+ */
+declare function useCreateAgent(): UseCreateAgentResult;
+/**
+ * Hook to update an agent
+ */
+declare function useUpdateAgent(id: string): UseUpdateAgentResult;
+/**
+ * Hook to execute an agent
+ */
+declare function useExecuteAgent(id: string): UseExecuteAgentResult;
+/**
+ * Hook to submit feedback for an agent execution
+ */
+declare function useSubmitAgentFeedback(executionId: string): UseSubmitAgentFeedbackResult;
+/**
+ * Hook to delete an agent
+ */
+declare function useDeleteAgent(): UseDeleteAgentResult;
+
+/**
+ * DO Provider
+ *
+ * Combined provider that wraps both @mdxui/admin AdminProvider
+ * and @dotdo/react AdminProvider for Durable Objects integration.
+ *
+ * @module @mdxui/do/hooks/dotdo
+ */
+
+/**
+ * Configuration for DO provider
+ */
+interface DOProps {
+    /** Child components */
+    children: React.ReactNode;
+    /**
+     * Durable Object namespace URL.
+     * If provided, creates a DotdoDataProvider automatically.
+     * @example 'https://api.example.com.ai/do/workspace'
+     */
+    ns?: string;
+    /**
+     * Pre-configured DataProvider instance.
+     * Use this for custom data provider configurations.
+     * Takes precedence over `ns` if both are provided.
+     */
+    dataProvider?: DataProvider;
+    /**
+     * Additional configuration for DotdoDataProvider.
+     * Only used when `ns` is provided.
+     */
+    dotdoConfig?: Omit<DotdoDataProviderConfig, 'ns'>;
+    /**
+     * @mdxui/admin AdminProvider configuration.
+     */
+    adminConfig?: Omit<AdminProviderProps, 'children'>;
+    /**
+     * Theme preference for the admin UI.
+     * @default 'system'
+     */
+    theme?: 'light' | 'dark' | 'system';
+    /**
+     * Base path for admin routes.
+     * @default ''
+     */
+    basename?: string;
+    /**
+     * Admin application title.
+     * @default 'Admin'
+     */
+    title?: string;
+    /**
+     * Logo element for the admin UI.
+     */
+    logo?: React.ReactNode;
+}
+/**
+ * Context value for DO Admin specific features (dotdo integration)
+ */
+interface DOAdminContextValue {
+    /** The configured data provider */
+    dataProvider: DataProvider | null;
+    /** Whether DO integration is enabled */
+    isDOEnabled: boolean;
+    /** The DO namespace URL if configured */
+    ns: string | null;
+}
+/**
+ * Combined admin provider for @mdxui/admin with Durable Objects support.
+ *
+ * Wraps both the @mdxui/admin AdminProvider and @dotdo/react AdminProvider,
+ * providing a unified context for admin applications backed by Durable Objects.
+ *
+ * @example
+ * ```tsx
+ * import { DO } from '@mdxui/do'
+ *
+ * function App() {
+ *   return (
+ *     <DO
+ *       ns="https://api.example.com.ai/do/workspace"
+ *       title="My Admin"
+ *       theme="dark"
+ *     >
+ *       <Resource name="users" list={UserList} edit={UserEdit} />
+ *       <Resource name="posts" list={PostList} create={PostCreate} />
+ *     </DO>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom data provider configuration
+ * import { DO, DotdoDataProvider } from '@mdxui/do'
+ *
+ * function App() {
+ *   const dataProvider = DotdoDataProvider({
+ *     ns: 'https://api.example.com.ai/do/workspace',
+ *     headers: { Authorization: 'Bearer token' },
+ *     timeout: 60000,
+ *   })
+ *
+ *   return (
+ *     <DO dataProvider={dataProvider} title="My Admin">
+ *       <AdminRoutes />
+ *     </DO>
+ *   )
+ * }
+ * ```
+ */
+declare function DO({ children, ns, dataProvider: providedDataProvider, dotdoConfig, adminConfig, theme, basename, title, logo, }: DOProps): React.ReactElement;
+declare namespace DO {
+    var displayName: string;
+}
+/**
+ * Hook to access DO-specific admin context.
+ *
+ * @returns DO context value
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isDOEnabled, ns } = useDOContext()
+ *
+ *   if (!isDOEnabled) {
+ *     return <div>DO backend not configured</div>
+ *   }
+ *
+ *   return <div>Connected to: {ns}</div>
+ * }
+ * ```
+ */
+declare function useDOContext(): DOAdminContextValue;
+/**
+ * Hook to check if DO integration is enabled.
+ *
+ * @returns Whether DO backend is configured
+ */
+declare function useIsDOEnabled(): boolean;
+
+/**
+ * useDO Hook
+ *
+ * Wrapper around @dotdo/react/admin useResource that provides
+ * @mdxui/do-specific defaults and type safety.
+ *
+ * @module @mdxui/do/hooks/dotdo
+ */
+
+/**
+ * Base record type for DO-backed resources.
+ * Records must have either $id (dotdo style) or id (standard style).
+ */
+interface BaseRecord {
+    /** Dotdo-style unique identifier */
+    $id?: string;
+    /** Standard unique identifier */
+    id?: string;
+    /** Additional fields */
+    [key: string]: unknown;
+}
+/**
+ * Configuration for useDO hook
+ *
+ * Extends the base @dotdo/react useResource config with
+ * @mdxui/do-specific options.
+ */
+interface UseDOConfig<T extends BaseRecord = BaseRecord> extends UseResourceConfig<T> {
+    /**
+     * Whether to show toast notifications on errors.
+     * @default true
+     */
+    showToasts?: boolean;
+    /**
+     * Transform function to apply to fetched data.
+     * Useful for mapping DO response to UI-expected format.
+     */
+    transform?: (data: T[]) => T[];
+    /**
+     * Custom empty state message when no data is returned.
+     */
+    emptyMessage?: string;
+}
+/**
+ * Return type for useDO hook
+ *
+ * Extends base result with additional @mdxui/do utilities.
+ */
+interface UseDOResult<T extends BaseRecord> extends UseResourceResult<T> {
+    /**
+     * Whether the data set is empty (no items after loading completes).
+     */
+    isEmpty: boolean;
+    /**
+     * Message to display when data is empty.
+     */
+    emptyMessage: string;
+    /**
+     * Whether the current data is stale (from cache, not fresh).
+     */
+    isStale: boolean;
+    /**
+     * Get a record by index from the current data.
+     */
+    getByIndex: (index: number) => T | undefined;
+}
+/**
+ * React hook for working with a Durable Objects resource collection.
+ *
+ * Wraps @dotdo/react/admin useResource with @mdxui/do conventions
+ * and additional utilities.
+ *
+ * @example
+ * ```tsx
+ * import { useDOResource } from '@mdxui/do'
+ *
+ * function UserList() {
+ *   const {
+ *     data: users,
+ *     isLoading,
+ *     isEmpty,
+ *     emptyMessage,
+ *     create,
+ *     update,
+ *     remove,
+ *   } = useDOResource<User>({
+ *     resource: 'User',
+ *     perPage: 20,
+ *     sort: { field: 'createdAt', order: 'desc' },
+ *   })
+ *
+ *   if (isLoading) return <LoadingSpinner />
+ *   if (isEmpty) return <EmptyState message={emptyMessage} />
+ *
+ *   return (
+ *     <DataGrid columns={columns} data={users} />
+ *   )
+ * }
+ * ```
+ *
+ * @param config - Configuration options for the resource hook
+ * @returns Resource state and mutation functions
+ */
+declare function useDOResource<T extends BaseRecord = BaseRecord>(config: UseDOConfig<T>): UseDOResult<T>;
+/**
+ * @deprecated Use useDOResource instead. This alias is kept for backward compatibility.
+ * Note: This conflicts with useDO from providers/do-provider.tsx, so import explicitly if needed.
+ */
+declare const useDOAdmin: typeof useDOResource;
+
+export { type BaseRecord, DO, type DOAdminContextValue, type DOProps, type DeleteThingOptions, type EntityRelationshipsData, type ExecuteAgentInput, type SubmitAgentFeedbackInput, type UseAgentExecutionResult, type UseAgentExecutionsResult, type UseAgentMetricsResult, type UseAgentResult, type UseAgentsResult, type UseCancelExecutionResult, type UseCreateAgentResult, type UseCreateRelationshipResult, type UseCreateThingResult, type UseCreateWorkflowResult, type UseDOConfig, type UseDOResult, type UseDeleteAgentResult, type UseDeleteRelationshipResult, type UseDeleteThingResult, type UseDeleteWorkflowResult, type UseEntityRelationshipsResult, type UseExecuteAgentResult, type UseGraphStatsResult, type UseGraphTraversalResult, type UseRelationshipsResult, type UseSubmitAgentFeedbackResult, type UseThingResult, type UseThingVersionsResult, type UseThingsResult, type UseTriggerWorkflowResult, type UseTypeStatsResult, type UseUpdateAgentResult, type UseUpdateThingResult, type UseUpdateWorkflowResult, type UseWorkflowExecutionResult, type UseWorkflowExecutionsResult, type UseWorkflowResult, type 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 };