import type { AnyObject, CollectionStats, Hook, NLPSearchResult, NLPSearchStreamResult, PinningRule, PinningRuleInsertObject, RegenerateReadAPIKeyResponse, SearchParams, SearchResult, TrainingSetInsertParameters } from './lib/types.js';
import type { ExecuteToolsBody, ExecuteToolsParsedResponse, InsertSystemPromptBody, InsertToolBody, Shelf, ShelfInsertObject, ShelfWithDocument, SystemPrompt, SystemPromptValidationResponse, Tool, TrainingSetQueryOptimizer, UpdateToolBody } from './index.js';
import type { CreateAISessionConfig } from './stream-manager.js';
import type { ClientRequestInit } from './common.js';
import { Profile } from './profile.js';
import { OramaCoreStream } from './stream-manager.js';
import { Client } from './common.js';
type AddHookConfig = {
    name: Hook;
    code: string;
};
type NewHookresponse = {
    hookID: string;
    code: string;
};
export type NLPSearchVersion = 'v1' | 'v1.1';
export type NLPSearchParams = {
    query: string;
    LLMConfig?: LLMConfig;
    userID?: string;
    version?: NLPSearchVersion;
};
export type LLMConfig = {
    provider: 'openai' | 'fireworks' | 'together' | 'google' | 'groq';
    model: string;
};
export type EnumStrategyStringLength = `string(${number})`;
export type EnumStrategy = 'explicit' | EnumStrategyStringLength;
export type TypeStrategy = {
    enum?: EnumStrategy;
};
export type CreateIndexParams = {
    id?: string;
    embeddings?: 'automatic' | 'all_properties' | string[];
    typeStrategy?: TypeStrategy;
};
export interface CollectionManagerConfig {
    cluster?: {
        writerURL?: string;
        readURL?: string;
    };
    collectionID: string;
    apiKey: string;
    authJwtURL?: string;
}
export declare class CollectionManager {
    private collectionID;
    private apiKey;
    private client;
    private profile?;
    ai: AINamespace;
    collections: CollectionsNamespace;
    index: IndexNamespace;
    hooks: HooksNamespace;
    logs: LogsNamespace;
    systemPrompts: SystemPromptsNamespace;
    tools: ToolsNamespace;
    identity: IdentityNamespace;
    trainingSets: TrainingSetsNamespace;
    mcp: MCPNamespace;
    shelves: ShelvesNamespace;
    pinningRules: PinningRulesNamespace;
    constructor(config: CollectionManagerConfig);
    search<R = AnyObject>(query: SearchParams, init?: ClientRequestInit): Promise<SearchResult<R>>;
}
declare class AINamespace {
    private client;
    private collectionID;
    private profile?;
    constructor(client: Client, collectionID: string, profile?: Profile);
    NLPSearch<R = AnyObject>(params: NLPSearchParams, init?: ClientRequestInit): Promise<NLPSearchResult<R>[]>;
    NLPSearchStream<R = AnyObject>(params: NLPSearchParams, init?: ClientRequestInit): AsyncGenerator<NLPSearchStreamResult<R>, void, unknown>;
    createAISession(config?: CreateAISessionConfig): OramaCoreStream;
}
declare class CollectionsNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    getStats(collectionID: string, init?: ClientRequestInit): Promise<CollectionStats>;
    regenerateReadAPIKey(init?: ClientRequestInit): Promise<RegenerateReadAPIKeyResponse>;
    getAllDocs<T = AnyObject>(id: string, init?: ClientRequestInit): Promise<T[]>;
}
declare class IndexNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    create(config: CreateIndexParams, init?: ClientRequestInit): Promise<void>;
    delete(indexID: string, init?: ClientRequestInit): Promise<void>;
    set(id: string): Index;
}
declare class HooksNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    insert(config: AddHookConfig, init?: ClientRequestInit): Promise<NewHookresponse>;
    list(init?: ClientRequestInit): Promise<Record<Hook, string | null>>;
    delete(hook: Hook, init?: ClientRequestInit): Promise<void>;
}
declare class PinningRulesNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    insert(rule: PinningRuleInsertObject): Promise<{
        success: boolean;
    }>;
    update(rule: PinningRuleInsertObject): Promise<{
        success: boolean;
    }>;
    list(): Promise<PinningRule[]>;
    listIDs(): Promise<string[]>;
    delete(id: string): Promise<{
        success: boolean;
    }>;
}
declare class ShelvesNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    insert(shelf: ShelfInsertObject): Promise<{
        success: boolean;
    }>;
    update(shelf: ShelfInsertObject): Promise<{
        success: boolean;
    }>;
    get(id: string): Promise<ShelfWithDocument>;
    list(): Promise<Shelf[]>;
    delete(id: string): Promise<{
        success: boolean;
    }>;
}
declare class LogsNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    stream(init?: ClientRequestInit): Promise<EventSource>;
}
declare class SystemPromptsNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    insert(systemPrompt: InsertSystemPromptBody, init?: ClientRequestInit): Promise<{
        success: boolean;
    }>;
    get(id: string, init?: ClientRequestInit): Promise<{
        system_prompt: SystemPrompt;
    }>;
    getAll(init?: ClientRequestInit): Promise<{
        system_prompts: SystemPrompt[];
    }>;
    delete(id: string, init?: ClientRequestInit): Promise<{
        success: boolean;
    }>;
    update(systemPrompt: SystemPrompt, init?: ClientRequestInit): Promise<{
        success: boolean;
    }>;
    validate(systemPrompt: SystemPrompt, init?: ClientRequestInit): Promise<{
        result: SystemPromptValidationResponse;
    }>;
}
declare class ToolsNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    insert(tool: InsertToolBody, init?: ClientRequestInit): Promise<void>;
    get(id: string, init?: ClientRequestInit): Promise<{
        tool: Tool;
    }>;
    getAll(init?: ClientRequestInit): Promise<{
        tools: Tool[];
    }>;
    delete(id: string, init?: ClientRequestInit): Promise<{
        success: boolean;
    }>;
    update(tool: UpdateToolBody, init?: ClientRequestInit): Promise<{
        success: boolean;
    }>;
    execute<Response = AnyObject>(tools: ExecuteToolsBody, init?: ClientRequestInit): Promise<ExecuteToolsParsedResponse<Response>>;
}
declare class IdentityNamespace {
    private profile?;
    constructor(profile?: Profile);
    get(): string | undefined;
    getUserId(): string;
    getAlias(): string | undefined;
    identify(identity: string): Promise<void>;
    alias(alias: string): Promise<void>;
    reset(): void;
}
declare class TrainingSetsNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    get(trainingSetId: string, init?: ClientRequestInit): Promise<{
        training_sets: TrainingSetQueryOptimizer;
    }>;
    generate(trainingSetId: string, LLMConfig?: LLMConfig, init?: ClientRequestInit): Promise<TrainingSetQueryOptimizer>;
    insert(trainingSetId: string, trainingSet: TrainingSetInsertParameters, init?: ClientRequestInit): Promise<{
        inserted: true;
    }>;
    delete(trainingSetId: string, init?: ClientRequestInit): Promise<{
        deleted: true;
    }>;
}
export declare class Index {
    private indexID;
    private collectionID;
    private oramaInterface;
    transaction: Transaction;
    constructor(oramaInterface: Client, collectionID: string, indexID: string);
    getIndexID(): string;
    reindex(init?: ClientRequestInit): Promise<void>;
    insertDocuments<T = AnyObject | AnyObject[]>(documents: T, init?: ClientRequestInit): Promise<void>;
    deleteDocuments(documentIDs: string | string[], init?: ClientRequestInit): Promise<void>;
    upsertDocuments<T = AnyObject[]>(documents: T, init?: ClientRequestInit): Promise<void>;
    createTemporaryIndex(temp_index_id?: string, init?: ClientRequestInit): Promise<string>;
    swapTemporaryIndex(target_index_id: string, temp_index_id: string, init?: ClientRequestInit): Promise<void>;
}
export declare class Transaction {
    private indexID;
    private collectionID;
    private tempIndexID;
    private oramaInterface;
    constructor(oramaInterface: Client, collectionID: string, indexID: string, tempIndexID?: string);
    open(init?: ClientRequestInit): Promise<void>;
    insertDocuments(documents: AnyObject | AnyObject[], init?: ClientRequestInit): Promise<void>;
    commit(init?: ClientRequestInit): Promise<void>;
    rollback(init?: ClientRequestInit): Promise<void>;
}
export declare class MCPNamespace {
    private client;
    private collectionID;
    constructor(client: Client, collectionID: string);
    updateDescription(newDescription: string, init?: ClientRequestInit): Promise<void>;
}
export {};
//# sourceMappingURL=collection.d.ts.map