import * as react from 'react';
import { ReactNode } from 'react';
import { CoreMemoryClientConfig, CoreMemoryClient } from '../core/client';
export { ApiResponse, CoreMemoryClient, CoreMemoryClientConfig, PaginatedResponse } from '../core/client';
import { MemoryEntry, UpdateMemoryRequest, CreateMemoryRequest, MemorySearchResult, SearchMemoryRequest } from '../core/types';
export { CreateMemoryRequest, MemoryEntry, MemorySearchResult, MemoryStatus, MemoryTopic, MemoryType, SearchMemoryRequest, UpdateMemoryRequest, UserMemoryStats } from '../core/types';

declare const MemoryContext: react.Context<CoreMemoryClient | null>;
interface MemoryProviderProps {
    children: ReactNode;
    config?: CoreMemoryClientConfig;
    apiKey?: string;
    apiUrl?: string;
    client?: CoreMemoryClient;
}
/**
 * Memory Provider Component
 *
 * Wrap your app or component tree with this provider to enable Memory hooks
 *
 * @example
 * ```tsx
 * function App() {
 *   return (
 *     <MemoryProvider apiKey={process.env.REACT_APP_LANONASIS_KEY}>
 *       <YourComponents />
 *     </MemoryProvider>
 *   );
 * }
 * ```
 */
declare function MemoryProvider({ children, config, apiKey, apiUrl, client: providedClient }: MemoryProviderProps): react.FunctionComponentElement<react.ProviderProps<CoreMemoryClient | null>>;

/**
 * Error handling for Memory Client
 * Browser-safe, no Node.js dependencies
 */
/**
 * Standardized error codes for programmatic error handling
 */
declare const ERROR_CODES: readonly ["API_ERROR", "AUTH_ERROR", "VALIDATION_ERROR", "TIMEOUT_ERROR", "RATE_LIMIT_ERROR", "NOT_FOUND", "NETWORK_ERROR", "FORBIDDEN", "CONFLICT", "SERVER_ERROR"];
type ErrorCode = typeof ERROR_CODES[number];
/**
 * Structured API error response - replaces plain string errors
 * Enables programmatic error handling with typed codes
 */
interface ApiErrorResponse {
    /** Machine-readable error code for programmatic handling */
    code: ErrorCode;
    /** Human-readable error message */
    message: string;
    /** HTTP status code if from API response */
    statusCode?: number;
    /** Additional error details (validation errors, etc.) */
    details?: unknown;
    /** Request ID for debugging/support */
    requestId?: string;
    /** Timestamp when error occurred */
    timestamp?: string;
}

/**
 * Hook to access the Memory Client instance
 *
 * @throws Error if used outside of MemoryProvider
 */
declare function useMemoryClient(): CoreMemoryClient;
/**
 * Result type for list/search hooks
 */
interface UseMemoriesResult {
    memories: MemoryEntry[];
    loading: boolean;
    error: ApiErrorResponse | null;
    refresh: () => Promise<void>;
}
/**
 * Hook to list memories with optional filtering
 *
 * @example
 * ```tsx
 * function MemoryList() {
 *   const { memories, loading, error, refresh } = useMemories({
 *     memory_type: 'project',
 *     limit: 20
 *   });
 *
 *   if (loading) return <div>Loading...</div>;
 *   if (error) return <div>Error: {error.message}</div>;
 *
 *   return (
 *     <div>
 *       {memories.map(m => <div key={m.id}>{m.title}</div>)}
 *       <button onClick={refresh}>Refresh</button>
 *     </div>
 *   );
 * }
 * ```
 */
declare function useMemories(options?: {
    page?: number;
    limit?: number;
    memory_type?: string;
    topic_id?: string;
    project_ref?: string;
    status?: string;
    tags?: string[];
    sort?: string;
    order?: 'asc' | 'desc';
}): UseMemoriesResult;
/**
 * Result type for single memory hook
 */
interface UseMemoryResult {
    memory: MemoryEntry | null;
    loading: boolean;
    error: ApiErrorResponse | null;
    refresh: () => Promise<void>;
    update: (updates: UpdateMemoryRequest) => Promise<void>;
    deleteMemory: () => Promise<void>;
}
/**
 * Hook to fetch and manage a single memory by ID
 *
 * @example
 * ```tsx
 * function MemoryDetail({ id }: { id: string }) {
 *   const { memory, loading, error, update, deleteMemory } = useMemory(id);
 *
 *   if (loading) return <div>Loading...</div>;
 *   if (error) return <div>Error: {error.message}</div>;
 *   if (!memory) return <div>Memory not found</div>;
 *
 *   return (
 *     <div>
 *       <h1>{memory.title}</h1>
 *       <p>{memory.content}</p>
 *       <button onClick={() => update({ title: 'Updated Title' })}>Update</button>
 *       <button onClick={deleteMemory}>Delete</button>
 *     </div>
 *   );
 * }
 * ```
 */
declare function useMemory(id: string): UseMemoryResult;
/**
 * Result type for create memory hook
 */
interface UseCreateMemoryResult {
    createMemory: (memory: CreateMemoryRequest) => Promise<MemoryEntry | null>;
    loading: boolean;
    error: ApiErrorResponse | null;
}
/**
 * Hook to create new memories
 *
 * @example
 * ```tsx
 * function CreateMemoryForm() {
 *   const { createMemory, loading, error } = useCreateMemory();
 *   const [title, setTitle] = useState('');
 *   const [content, setContent] = useState('');
 *
 *   const handleSubmit = async (e: React.FormEvent) => {
 *     e.preventDefault();
 *     const memory = await createMemory({ title, content });
 *     if (memory) {
 *       console.log('Created:', memory.id);
 *       setTitle('');
 *       setContent('');
 *     }
 *   };
 *
 *   return (
 *     <form onSubmit={handleSubmit}>
 *       <input value={title} onChange={e => setTitle(e.target.value)} />
 *       <textarea value={content} onChange={e => setContent(e.target.value)} />
 *       <button type="submit" disabled={loading}>Create</button>
 *       {error && <div>Error: {error.message}</div>}
 *     </form>
 *   );
 * }
 * ```
 */
declare function useCreateMemory(): UseCreateMemoryResult;
/**
 * Result type for search memories hook
 */
interface UseSearchMemoriesResult {
    results: MemorySearchResult[];
    loading: boolean;
    error: ApiErrorResponse | null;
    search: (query: string, options?: Omit<SearchMemoryRequest, 'query'>) => Promise<void>;
    totalResults: number;
    searchTime: number;
}
/**
 * Hook to search memories with debouncing
 *
 * @example
 * ```tsx
 * function MemorySearch() {
 *   const { results, loading, error, search } = useSearchMemories();
 *   const [query, setQuery] = useState('');
 *
 *   useEffect(() => {
 *     if (query.length > 2) {
 *       search(query, { limit: 10 });
 *     }
 *   }, [query, search]);
 *
 *   return (
 *     <div>
 *       <input
 *         value={query}
 *         onChange={e => setQuery(e.target.value)}
 *         placeholder="Search memories..."
 *       />
 *       {loading && <div>Searching...</div>}
 *       {error && <div>Error: {error.message}</div>}
 *       {results.map(r => (
 *         <div key={r.id}>
 *           <h3>{r.title}</h3>
 *           <span>Score: {r.similarity_score.toFixed(2)}</span>
 *         </div>
 *       ))}
 *     </div>
 *   );
 * }
 * ```
 */
declare function useSearchMemories(debounceMs?: number): UseSearchMemoriesResult;

export { MemoryContext, MemoryProvider, useCreateMemory, useMemories, useMemory, useMemoryClient, useSearchMemories };
export type { ApiErrorResponse, ErrorCode, MemoryProviderProps, UseCreateMemoryResult, UseMemoriesResult, UseMemoryResult, UseSearchMemoriesResult };