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

/**
 * Vue Plugin for Memory Client
 *
 * Provides a Memory Client instance to all components via Vue's provide/inject
 */

declare const MEMORY_CLIENT_KEY: InjectionKey<CoreMemoryClient>;
interface MemoryPluginOptions extends CoreMemoryClientConfig {
    /** Automatically authenticate on plugin installation */
    autoAuth?: boolean;
}
/**
 * Vue plugin for Memory Client
 *
 * @example
 * ```ts
 * import { createApp } from 'vue';
 * import { createMemoryPlugin } from '@lanonasis/memory-client/vue';
 * import App from './App.vue';
 *
 * const app = createApp(App);
 *
 * app.use(createMemoryPlugin({
 *   apiUrl: 'https://api.lanonasis.com',
 *   apiKey: import.meta.env.VITE_LANONASIS_KEY
 * }));
 *
 * app.mount('#app');
 * ```
 */
declare function createMemoryPlugin(options: MemoryPluginOptions): {
    install(app: App): void;
};
/**
 * Hook to access the Memory Client instance
 *
 * @throws Error if used without installing the plugin
 */
declare function useMemoryClient(): CoreMemoryClient;

/**
 * Composable to list memories with optional filtering
 *
 * @example
 * ```vue
 * <script setup>
 * import { useMemories } from '@lanonasis/memory-client/vue';
 *
 * const { memories, loading, error, refresh } = useMemories({
 *   memory_type: 'project',
 *   limit: 20
 * });
 * </script>
 *
 * <template>
 *   <div v-if="loading">Loading...</div>
 *   <div v-else-if="error">Error: {{ error.message }}</div>
 *   <div v-else>
 *     <div v-for="memory in memories" :key="memory.id">
 *       {{ memory.title }}
 *     </div>
 *     <button @click="refresh">Refresh</button>
 *   </div>
 * </template>
 * ```
 */
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';
}): {
    memories: vue.ComputedRef<{
        id: string;
        title: string;
        content: string;
        summary?: string | undefined;
        memory_type: MemoryType;
        status: MemoryStatus;
        relevance_score?: number | undefined;
        access_count: number;
        last_accessed?: string | undefined;
        user_id: string;
        topic_id?: string | undefined;
        project_ref?: string | undefined;
        tags: string[];
        metadata?: Record<string, unknown> | undefined;
        created_at: string;
        updated_at: string;
    }[]>;
    loading: vue.ComputedRef<boolean>;
    error: vue.ComputedRef<{
        code: ErrorCode;
        message: string;
        statusCode?: number | undefined;
        details?: unknown;
        requestId?: string | undefined;
        timestamp?: string | undefined;
    } | null>;
    refresh: () => Promise<void>;
};
/**
 * Composable to fetch and manage a single memory by ID
 *
 * @example
 * ```vue
 * <script setup>
 * import { useMemory } from '@lanonasis/memory-client/vue';
 *
 * const props = defineProps<{ id: string }>();
 * const { memory, loading, error, update, deleteMemory } = useMemory(() => props.id);
 * </script>
 *
 * <template>
 *   <div v-if="loading">Loading...</div>
 *   <div v-else-if="error">Error: {{ error.message }}</div>
 *   <div v-else-if="memory">
 *     <h1>{{ memory.title }}</h1>
 *     <p>{{ memory.content }}</p>
 *     <button @click="update({ title: 'Updated Title' })">Update</button>
 *     <button @click="deleteMemory">Delete</button>
 *   </div>
 * </template>
 * ```
 */
declare function useMemory(id: Ref<string> | (() => string) | string): {
    memory: vue.ComputedRef<{
        id: string;
        title: string;
        content: string;
        summary?: string | undefined;
        memory_type: MemoryType;
        status: MemoryStatus;
        relevance_score?: number | undefined;
        access_count: number;
        last_accessed?: string | undefined;
        user_id: string;
        topic_id?: string | undefined;
        project_ref?: string | undefined;
        tags: string[];
        metadata?: Record<string, unknown> | undefined;
        created_at: string;
        updated_at: string;
    } | null>;
    loading: vue.ComputedRef<boolean>;
    error: vue.ComputedRef<{
        code: ErrorCode;
        message: string;
        statusCode?: number | undefined;
        details?: unknown;
        requestId?: string | undefined;
        timestamp?: string | undefined;
    } | null>;
    refresh: () => Promise<void>;
    update: (updates: UpdateMemoryRequest) => Promise<void>;
    deleteMemory: () => Promise<void>;
};
/**
 * Composable to create new memories
 *
 * @example
 * ```vue
 * <script setup>
 * import { ref } from 'vue';
 * import { useCreateMemory } from '@lanonasis/memory-client/vue';
 *
 * const title = ref('');
 * const content = ref('');
 * const { createMemory, loading, error } = useCreateMemory();
 *
 * async function handleSubmit() {
 *   const memory = await createMemory({
 *     title: title.value,
 *     content: content.value
 *   });
 *   if (memory) {
 *     console.log('Created:', memory.id);
 *     title.value = '';
 *     content.value = '';
 *   }
 * }
 * </script>
 *
 * <template>
 *   <form @submit.prevent="handleSubmit">
 *     <input v-model="title" placeholder="Title" />
 *     <textarea v-model="content" placeholder="Content" />
 *     <button type="submit" :disabled="loading">Create</button>
 *     <div v-if="error">Error: {{ error.message }}</div>
 *   </form>
 * </template>
 * ```
 */
declare function useCreateMemory(): {
    createMemory: (memory: CreateMemoryRequest) => Promise<MemoryEntry | null>;
    loading: vue.ComputedRef<boolean>;
    error: vue.ComputedRef<{
        code: ErrorCode;
        message: string;
        statusCode?: number | undefined;
        details?: unknown;
        requestId?: string | undefined;
        timestamp?: string | undefined;
    } | null>;
};
/**
 * Composable to search memories
 *
 * @example
 * ```vue
 * <script setup>
 * import { ref, watch } from 'vue';
 * import { useSearchMemories } from '@lanonasis/memory-client/vue';
 *
 * const query = ref('');
 * const { results, loading, error, search, totalResults, searchTime } = useSearchMemories();
 *
 * watch(query, (newQuery) => {
 *   if (newQuery.length > 2) {
 *     search(newQuery, { limit: 10 });
 *   }
 * });
 * </script>
 *
 * <template>
 *   <div>
 *     <input v-model="query" placeholder="Search memories..." />
 *     <div v-if="loading">Searching...</div>
 *     <div v-if="error">Error: {{ error.message }}</div>
 *     <div v-for="result in results" :key="result.id">
 *       <h3>{{ result.title }}</h3>
 *       <span>Score: {{ result.similarity_score.toFixed(2) }}</span>
 *     </div>
 *     <div v-if="totalResults > 0">
 *       Found {{ totalResults }} results in {{ searchTime }}ms
 *     </div>
 *   </div>
 * </template>
 * ```
 */
declare function useSearchMemories(debounceMs?: number): {
    results: vue.ComputedRef<{
        similarity_score: number;
        id: string;
        title: string;
        content: string;
        summary?: string | undefined;
        memory_type: MemoryType;
        status: MemoryStatus;
        relevance_score?: number | undefined;
        access_count: number;
        last_accessed?: string | undefined;
        user_id: string;
        topic_id?: string | undefined;
        project_ref?: string | undefined;
        tags: string[];
        metadata?: Record<string, unknown> | undefined;
        created_at: string;
        updated_at: string;
    }[]>;
    loading: vue.ComputedRef<boolean>;
    error: vue.ComputedRef<{
        code: ErrorCode;
        message: string;
        statusCode?: number | undefined;
        details?: unknown;
        requestId?: string | undefined;
        timestamp?: string | undefined;
    } | null>;
    search: (query: string, options?: Omit<SearchMemoryRequest, "query">) => Promise<void>;
    totalResults: vue.ComputedRef<number>;
    searchTime: vue.ComputedRef<number>;
};

/**
 * 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;
}

export { MEMORY_CLIENT_KEY, createMemoryPlugin, useCreateMemory, useMemories, useMemory, useMemoryClient, useSearchMemories };
export type { ApiErrorResponse, ErrorCode, MemoryPluginOptions };