@mdxui/do 2.1.1 → 3.0.0

package/dist/hooks/index.d.ts

@@ -1,801 +1,533 @@
-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';
+import { N as Namespace, S as SemanticType, c as ThingFilter, T as Thing } from '../thing-BVhCTzOi.js';
+export { DeleteThingOptions, UseCreateThingResult, UseDeleteThingResult, UseThingResult, UseThingVersionsResult, UseThingsResult, UseTypeStatsResult, UseUpdateThingResult, useCreateThing, useDeleteThing, useThing, useThingVersions, useThings, useTypeStats, useUpdateThing } from './things/index.js';
+export { t as thingsKeys } from '../query-keys-BC901wog.js';
+import 'zod';
+import '@tanstack/react-query';
+import '../schemas/index.js';
+import '../agents-2_r9e9i7.js';
 
 /**
- * Type definitions for Things hooks
- *
- * Provides return types for query and mutation hooks.
- */
-
+ * Property definition in a schema
+ */
+interface SchemaProperty {
+    /** Property name */
+    name: string;
+    /** Property type (string, number, boolean, object, array, etc.) */
+    type: string;
+    /** Whether the property is required */
+    required?: boolean;
+    /** Property description */
+    description?: string;
+    /** Default value */
+    default?: unknown;
+    /** For array types, the item type */
+    items?: SchemaProperty;
+    /** For object types, nested properties */
+    properties?: SchemaProperty[];
+}
 /**
- * Return type for useThings hook
+ * Schema definition for a resource type
  */
-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';
+interface SchemaDefinition {
+    /** Schema name (usually the type name) */
+    name: string;
+    /** Namespace this schema belongs to */
+    ns?: string;
+    /** Human-readable description */
+    description?: string;
+    /** Properties defined in this schema */
+    properties: SchemaProperty[];
+    /** Primary key field(s) */
+    primaryKey?: string | string[];
+    /** Indexes defined on this schema */
+    indexes?: Array<{
+        name: string;
+        fields: string[];
+        unique?: boolean;
+    }>;
+    /** Timestamps */
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 /**
- * 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';
+ * Result from schema discovery
+ */
+interface SchemaDiscoveryResult {
+    /** Available schemas */
+    schemas: SchemaDefinition[];
+    /** Available namespaces */
+    namespaces: string[];
+    /** Types by namespace */
+    typesByNamespace: Record<string, string[]>;
+    /** Server version/info */
+    serverInfo?: {
+        version?: string;
+        capabilities?: string[];
+    };
 }
 /**
- * Return type for useThingVersions hook
+ * Options for useSchema 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';
+interface UseSchemaOptions {
+    /** Filter by namespace */
+    ns?: string;
+    /** Filter by type name */
+    type?: string;
+    /** Whether to include system schemas */
+    includeSystem?: boolean;
+    /** Enable/disable the query */
+    enabled?: boolean;
 }
 /**
- * Return type for useTypeStats hook
+ * Result from useSchema hook
  */
-interface UseTypeStatsResult {
-    /** The type statistics, or null if not yet loaded */
-    data: TypeStats | null;
-    /** True during initial load */
+interface UseSchemaResult {
+    /** Schema discovery result */
+    data: SchemaDiscoveryResult | null;
+    /** Loading state */
     isLoading: boolean;
-    /** Error from the query, or null */
+    /** Error if any */
     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 */
+    /** Refetch function */
+    refetch: () => Promise<unknown>;
+    /** Whether data is being refetched */
     isRefetching: boolean;
-    /** True if any fetch is in progress */
-    isFetching: boolean;
-    /** Query status: 'pending', 'success', or 'error' */
-    status: 'pending' | 'success' | 'error';
 }
+declare const schemaKeys: {
+    all: readonly ["schema"];
+    discovery: (ns?: string) => readonly ["schema", "discovery", string];
+    definition: (ns: string, type: string) => readonly ["schema", "definition", string, string];
+};
 /**
- * Return type for useCreateThing hook
+ * Hook to discover schemas from the DO backend
+ *
+ * @example
+ * ```tsx
+ * function SchemaExplorer() {
+ *   const { data, isLoading } = useSchema()
+ *
+ *   if (isLoading) return <div>Loading schemas...</div>
+ *
+ *   return (
+ *     <ul>
+ *       {data?.schemas.map(schema => (
+ *         <li key={schema.name}>{schema.name}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ * ```
  */
-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;
-}
+declare function useSchema(options?: UseSchemaOptions): UseSchemaResult;
 /**
- * Return type for useUpdateThing hook
+ * Hook to get a specific schema definition
+ *
+ * @example
+ * ```tsx
+ * function SchemaViewer({ ns, type }: { ns: string; type: string }) {
+ *   const { data, isLoading } = useSchemaDefinition(ns, type)
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *
+ *   return (
+ *     <pre>{JSON.stringify(data, null, 2)}</pre>
+ *   )
+ * }
+ * ```
  */
-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 */
+declare function useSchemaDefinition(ns: string, type: string, options?: {
+    enabled?: boolean;
+}): {
+    data: SchemaDefinition | null;
     isLoading: boolean;
-    /** Error from the mutation, or null */
     error: Error | null;
-    /** True if the mutation succeeded */
-    isSuccess: boolean;
-    /** Reset the mutation state */
-    reset: () => void;
-}
+    refetch: () => Promise<unknown>;
+};
+
 /**
- * Options for delete operation
+ * Options for useNamespaces hook
  */
-interface DeleteThingOptions {
-    /** If true, permanently delete instead of soft delete */
-    hard?: boolean;
+interface UseNamespacesOptions {
+    /** Include hidden/system namespaces */
+    includeSystem?: boolean;
+    /** Enable/disable the query */
+    enabled?: boolean;
 }
 /**
- * Return type for useDeleteThing hook
+ * Result from useNamespaces 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 */
+interface UseNamespacesResult {
+    /** List of namespaces */
+    data: Namespace[] | null;
+    /** Loading state */
     isLoading: boolean;
-    /** Error from the mutation, or null */
+    /** Error if any */
     error: Error | null;
-    /** True if the mutation succeeded */
-    isSuccess: boolean;
-    /** Reset the mutation state */
-    reset: () => void;
+    /** Refetch function */
+    refetch: () => Promise<unknown>;
+    /** Whether data is being refetched */
+    isRefetching: boolean;
+    /** Query status */
+    status: 'pending' | 'error' | 'success';
 }
-
-/**
- * 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;
+declare const namespacesKeys: {
+    all: readonly ["namespaces"];
+    list: (includeSystem?: boolean) => readonly ["namespaces", "list", boolean];
+};
 /**
- * Hook to delete a Thing (soft delete by default)
+ * Hook to fetch available namespaces
  *
- * Automatically invalidates the related cache entries on success.
+ * @example
+ * ```tsx
+ * function NamespaceSelector() {
+ *   const { data: namespaces, isLoading } = useNamespaces()
  *
- * 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
+ *   if (isLoading) return <div>Loading namespaces...</div>
  *
- * Note: DataProvider mode always performs soft delete. For hard delete,
- * use RPC or REST API modes with `{ hard: true }` option.
+ *   return (
+ *     <select>
+ *       {namespaces?.map(ns => (
+ *         <option key={ns.id} value={ns.name}>
+ *           {ns.name}
+ *         </option>
+ *       ))}
+ *     </select>
+ *   )
+ * }
+ * ```
  */
-declare function useDeleteThing(ns: string, type: string, id: string): UseDeleteThingResult;
+declare function useNamespaces(options?: UseNamespacesOptions): UseNamespacesResult;
 
 /**
- * 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
+ * Options for useTypes hook
  */
-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];
-};
+interface UseTypesOptions {
+    /** Namespace to fetch types from (defaults to current namespace) */
+    ns?: string;
+    /** Include hidden/system types */
+    includeSystem?: boolean;
+    /** Enable/disable the query */
+    enabled?: boolean;
+}
 /**
- * Query keys for Agents resource
- *
- * Includes keys for:
- * - Agent lists and details
- * - Agent metrics (per-agent)
- * - Agent executions (list and detail)
+ * Result from useTypes hook
  */
-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];
+interface UseTypesResult {
+    /** List of types */
+    data: SemanticType[] | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Refetch function */
+    refetch: () => Promise<unknown>;
+    /** Whether data is being refetched */
+    isRefetching: boolean;
+    /** Query status */
+    status: 'pending' | 'error' | 'success';
+}
+declare const typesKeys: {
+    all: readonly ["types"];
+    list: (ns: string, includeSystem?: boolean) => readonly ["types", "list", string, boolean];
 };
 /**
- * Query keys for Workflows resource
+ * Hook to fetch available types within a namespace
  *
- * 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
+ * @example
+ * ```tsx
+ * function TypeSelector({ ns }: { ns: string }) {
+ *   const { data: types, isLoading } = useTypes({ ns })
  *
- * 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
+ *   if (isLoading) return <div>Loading types...</div>
+ *
+ *   return (
+ *     <select>
+ *       {types?.map(type => (
+ *         <option key={type.id} value={type.name}>
+ *           {type.label}
+ *         </option>
+ *       ))}
+ *     </select>
+ *   )
+ * }
+ * ```
  */
-declare function useDeleteWorkflow(): UseDeleteWorkflowResult;
+declare function useTypes(options?: UseTypesOptions): UseTypesResult;
 
 /**
- * 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
+ * Subscription event types
  */
-type UseUpdateAgentResult = UseMutationResult<Agent, Error, Partial<Agent>>;
+type SubscriptionEventType = 'created' | 'updated' | 'deleted' | 'connected' | 'disconnected' | 'error';
 /**
- * Input type for useExecuteAgent mutation
+ * Subscription event payload
  */
-interface ExecuteAgentInput {
-    task: string;
-    context?: Record<string, unknown>;
+interface SubscriptionEvent {
+    /** Event type */
+    type: SubscriptionEventType;
+    /** Affected Thing (for created/updated/deleted) */
+    thing?: Thing;
+    /** Thing ID (for deleted events) */
+    thingId?: string;
+    /** Error message (for error events) */
+    error?: string;
+    /** Timestamp */
+    timestamp: Date;
 }
 /**
- * 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
+ * Subscription state
  */
-declare function useAgentExecutions(filter?: AgentExecutionFilter): UseAgentExecutionsResult;
+type SubscriptionState = 'connecting' | 'connected' | 'disconnected' | 'error';
 /**
- * Hook to fetch a single agent execution
+ * Options for useThingSubscription hook
  */
-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'
-     */
+interface UseThingSubscriptionOptions {
+    /** Namespace to subscribe to */
     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;
+    /** Type to subscribe to (optional, subscribes to all if not specified) */
+    type?: string;
+    /** Specific Thing ID to subscribe to */
+    id?: string;
+    /** Filter for subscription */
+    filter?: ThingFilter;
+    /** Callback when a Thing is created */
+    onCreated?: (thing: Thing) => void;
+    /** Callback when a Thing is updated */
+    onUpdated?: (thing: Thing) => void;
+    /** Callback when a Thing is deleted */
+    onDeleted?: (thingId: string) => void;
+    /** Callback for any event */
+    onEvent?: (event: SubscriptionEvent) => void;
+    /** Callback for connection state changes */
+    onStateChange?: (state: SubscriptionState) => void;
+    /** Enable/disable subscription */
+    enabled?: boolean;
+    /** Auto-invalidate React Query cache on updates */
+    invalidateOnUpdate?: boolean;
 }
 /**
- * Context value for DO Admin specific features (dotdo integration)
+ * Result from useThingSubscription hook
  */
-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;
+interface UseThingSubscriptionResult {
+    /** Current subscription state */
+    state: SubscriptionState;
+    /** Recent events (limited buffer) */
+    events: SubscriptionEvent[];
+    /** Whether currently connected */
+    isConnected: boolean;
+    /** Last error if any */
+    error: Error | null;
+    /** Manually reconnect */
+    reconnect: () => void;
+    /** Disconnect */
+    disconnect: () => void;
 }
 /**
- * Combined admin provider for @mdxui/admin with Durable Objects support.
+ * Hook for real-time Thing subscriptions
  *
- * Wraps both the @mdxui/admin AdminProvider and @dotdo/react AdminProvider,
- * providing a unified context for admin applications backed by Durable Objects.
+ * Subscribes to changes on Things and provides real-time updates.
+ * Automatically invalidates React Query cache when data changes.
  *
- * @example
+ * @example Subscribe to all Things of a type
  * ```tsx
- * import { DO } from '@mdxui/do'
+ * function TaskList() {
+ *   const { state, events } = useThingSubscription({
+ *     type: 'Task',
+ *     onCreated: (task) => console.log('New task:', task),
+ *     onUpdated: (task) => console.log('Task updated:', task),
+ *   })
  *
- * 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>
+ *     <div>
+ *       <div>Status: {state}</div>
+ *       <div>Recent events: {events.length}</div>
+ *     </div>
  *   )
  * }
  * ```
  *
- * @example
+ * @example Subscribe to a specific Thing
  * ```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,
+ * function TaskDetail({ id }: { id: string }) {
+ *   useThingSubscription({
+ *     type: 'Task',
+ *     id,
+ *     onUpdated: (task) => console.log('Task updated:', task),
  *   })
  *
- *   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;
-}
+declare function useThingSubscription(options?: UseThingSubscriptionOptions): UseThingSubscriptionResult;
 /**
- * Hook to access DO-specific admin context.
+ * Hook to subscribe to a single Thing's changes
  *
- * @returns DO context value
+ * Convenience wrapper around useThingSubscription for single-Thing use cases.
  *
  * @example
  * ```tsx
- * function MyComponent() {
- *   const { isDOEnabled, ns } = useDOContext()
- *
- *   if (!isDOEnabled) {
- *     return <div>DO backend not configured</div>
- *   }
+ * function TaskEditor({ ns, type, id }: ThingParams) {
+ *   const { isConnected, lastUpdate } = useSingleThingSubscription({
+ *     ns,
+ *     type,
+ *     id,
+ *     onUpdated: (thing) => {
+ *       // Handle optimistic update conflicts
+ *     },
+ *   })
  *
- *   return <div>Connected to: {ns}</div>
+ *   return (
+ *     <div>
+ *       {isConnected && <Badge>Live</Badge>}
+ *       {/* Editor UI *\/}
+ *     </div>
+ *   )
  * }
  * ```
  */
-declare function useDOContext(): DOAdminContextValue;
-/**
- * Hook to check if DO integration is enabled.
- *
- * @returns Whether DO backend is configured
- */
-declare function useIsDOEnabled(): boolean;
+declare function useSingleThingSubscription(options: {
+    ns: string;
+    type: string;
+    id: string;
+    onUpdated?: (thing: Thing) => void;
+    onDeleted?: () => void;
+    enabled?: boolean;
+}): {
+    isConnected: boolean;
+    lastUpdate: Date | null;
+    error: Error | null;
+};
 
 /**
- * useDO Hook
- *
- * Wrapper around @dotdo/react/admin useResource that provides
- * @mdxui/do-specific defaults and type safety.
- *
- * @module @mdxui/do/hooks/dotdo
- */
-
+ * Represents a single edit operation that can be undone/redone
+ */
+interface EditOperation {
+    /** Type of operation */
+    type: 'cell_update';
+    /** Row index that was modified */
+    rowIndex: number;
+    /** Column ID that was modified */
+    columnId: string;
+    /** Value before the edit */
+    oldValue: unknown;
+    /** Value after the edit */
+    newValue: unknown;
+    /** Timestamp of the operation */
+    timestamp: number;
+}
 /**
- * Base record type for DO-backed resources.
- * Records must have either $id (dotdo style) or id (standard style).
+ * Configuration for the edit history hook
  */
-interface BaseRecord {
-    /** Dotdo-style unique identifier */
-    $id?: string;
-    /** Standard unique identifier */
-    id?: string;
-    /** Additional fields */
-    [key: string]: unknown;
+interface UseEditHistoryOptions {
+    /** Maximum number of operations to keep in history (default: 50) */
+    maxHistory?: number;
+    /** Callback when undo is triggered */
+    onUndo?: (operation: EditOperation) => void;
+    /** Callback when redo is triggered */
+    onRedo?: (operation: EditOperation) => void;
 }
 /**
- * Configuration for useDO hook
+ * Return type for the edit history hook
+ */
+interface UseEditHistoryReturn {
+    /** Push a new edit operation to history */
+    pushOperation: (operation: Omit<EditOperation, 'timestamp'>) => void;
+    /** Undo the last operation */
+    undo: () => EditOperation | null;
+    /** Redo the last undone operation */
+    redo: () => EditOperation | null;
+    /** Whether undo is available */
+    canUndo: boolean;
+    /** Whether redo is available */
+    canRedo: boolean;
+    /** Number of operations that can be undone */
+    undoCount: number;
+    /** Number of operations that can be redone */
+    redoCount: number;
+    /** Clear all history */
+    clearHistory: () => void;
+}
+/**
+ * Custom hook for managing edit history with undo/redo support
+ *
+ * This hook provides a dual-stack architecture for undo/redo operations,
+ * without keyboard shortcuts (use useKeyboardShortcuts separately).
  *
- * Extends the base @dotdo/react useResource config with
- * @mdxui/do-specific options.
+ * @example
+ * ```tsx
+ * const { pushOperation, undo, redo, canUndo, canRedo } = useEditHistory({
+ *   onUndo: (op) => updateCell(op.rowIndex, op.columnId, op.oldValue),
+ *   onRedo: (op) => updateCell(op.rowIndex, op.columnId, op.newValue),
+ * })
+ *
+ * // When a cell is edited:
+ * pushOperation({
+ *   type: 'cell_update',
+ *   rowIndex: 0,
+ *   columnId: 'name',
+ *   oldValue: 'John',
+ *   newValue: 'Jane',
+ * })
+ * ```
  */
-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;
+declare function useEditHistory(options?: UseEditHistoryOptions): UseEditHistoryReturn;
+
+/**
+ * Configuration for a single keyboard shortcut
+ */
+interface KeyboardShortcutConfig {
+    /** The key to listen for (e.g., 'z', 'y', 'Enter') */
+    key: string;
+    /** Whether Ctrl key must be pressed (Windows/Linux) */
+    ctrl?: boolean;
+    /** Whether Shift key must be pressed */
+    shift?: boolean;
+    /** Whether Meta key must be pressed (Mac Command key) */
+    meta?: boolean;
+    /** Handler function to call when shortcut is triggered */
+    handler: () => void;
+    /** Whether this shortcut is disabled */
+    disabled?: boolean;
 }
 /**
- * Return type for useDO hook
- *
- * Extends base result with additional @mdxui/do utilities.
+ * Options for the useKeyboardShortcuts hook
  */
-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;
+interface UseKeyboardShortcutsOptions {
+    /** Whether to enable the shortcuts (default: true) */
+    enabled?: boolean;
+    /** Whether to prevent default behavior (default: true) */
+    preventDefault?: boolean;
+    /** Whether to stop propagation (default: false) */
+    stopPropagation?: boolean;
 }
 /**
- * React hook for working with a Durable Objects resource collection.
+ * Custom hook for registering global keyboard shortcuts
  *
- * Wraps @dotdo/react/admin useResource with @mdxui/do conventions
- * and additional utilities.
+ * This hook registers keyboard event listeners on the document and
+ * triggers handlers when matching shortcuts are pressed. It automatically
+ * bypasses shortcuts when the user is typing in an input, textarea, or
+ * contentEditable element.
  *
  * @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} />
- *   )
- * }
+ * // Basic undo/redo shortcuts
+ * useKeyboardShortcuts([
+ *   { key: 'z', ctrl: true, handler: handleUndo },
+ *   { key: 'z', ctrl: true, shift: true, handler: handleRedo },
+ * ])
+ *
+ * // With options
+ * useKeyboardShortcuts(
+ *   [{ key: 's', ctrl: true, handler: handleSave }],
+ *   { preventDefault: true }
+ * )
+ *
+ * // Conditionally disabled
+ * useKeyboardShortcuts(
+ *   [{ key: 'z', ctrl: true, handler: handleUndo, disabled: !canUndo }],
+ * )
  * ```
- *
- * @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;
+declare function useKeyboardShortcuts(shortcuts: KeyboardShortcutConfig[], options?: UseKeyboardShortcutsOptions): void;
 
-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 };
+export { type EditOperation as CellEditOperation, type KeyboardShortcutConfig, type SchemaDefinition, type SchemaDiscoveryResult, type SchemaProperty, type SubscriptionEvent, type SubscriptionEventType, type SubscriptionState, type UseEditHistoryReturn as UseEditHistoryHookReturn, type UseEditHistoryOptions, type UseKeyboardShortcutsOptions, type UseNamespacesOptions, type UseNamespacesResult, type UseSchemaOptions, type UseSchemaResult, type UseThingSubscriptionOptions, type UseThingSubscriptionResult, type UseTypesOptions, type UseTypesResult, namespacesKeys, schemaKeys, typesKeys, useEditHistory, useKeyboardShortcuts, useNamespaces, useSchema, useSchemaDefinition, useSingleThingSubscription, useThingSubscription, useTypes };