import type { ArrayOperator } from '@mastra/core/vector/filter';
import { BaseFilterTranslator } from '@mastra/core/vector/filter';
import type { BasicOperator } from '@mastra/core/vector/filter';
import type { CreateIndexArgs } from '@mastra/core/vector';
import type { CreateIndexParams } from '@mastra/core/vector';
import type { ElementOperator } from '@mastra/core/vector/filter';
import type { EvalRow } from '@mastra/core/storage';
import type { IndexStats } from '@mastra/core/vector';
import type { ISSLConfig } from 'pg-promise/typescript/pg-subset';
import type { LogicalOperator } from '@mastra/core/vector/filter';
import { MastraStorage } from '@mastra/core/storage';
import { MastraVector } from '@mastra/core/vector';
import type { MessageType } from '@mastra/core/memory';
import type { NumericOperator } from '@mastra/core/vector/filter';
import type { OperatorSupport } from '@mastra/core/vector/filter';
import type { ParamsToArgs } from '@mastra/core/vector';
import type { QueryResult } from '@mastra/core/vector';
import type { QueryVectorArgs } from '@mastra/core/vector';
import type { QueryVectorParams } from '@mastra/core/vector';
import type { RegexOperator } from '@mastra/core/vector/filter';
import type { StorageColumn } from '@mastra/core/storage';
import type { StorageGetMessagesArg } from '@mastra/core/storage';
import type { StorageThreadType } from '@mastra/core/memory';
import type { TABLE_NAMES } from '@mastra/core/storage';
import type { UpsertVectorParams } from '@mastra/core/vector';
import type { VectorFilter } from '@mastra/core/vector/filter';
import type { WorkflowRunState } from '@mastra/core/workflows';

export declare const baseTestConfigs: {
    smokeTests: {
        dimension: number;
        size: number;
        k: number;
        queryCount: number;
    }[];
    '64': {
        dimension: number;
        size: number;
        k: number;
        queryCount: number;
    }[];
    '384': {
        dimension: number;
        size: number;
        k: number;
        queryCount: number;
    }[];
    '1024': {
        dimension: number;
        size: number;
        k: number;
        queryCount: number;
    }[];
    stressTests: {
        dimension: number;
        size: number;
        k: number;
        queryCount: number;
    }[];
};

export declare function buildFilterQuery(filter: VectorFilter, minScore: number): FilterResult;

export declare const calculateRecall: (actual: number[], expected: number[], k: number) => number;

export declare const calculateTimeout: (dimension: number, size: number, k: number) => number;

export declare function cosineSimilarity(a: number[], b: number[]): number;

export declare const FILTER_OPERATORS: Record<string, OperatorFn>;

declare type FilterOperator = {
    sql: string;
    needsValue: boolean;
    transformValue?: (value: any) => any;
};

export declare interface FilterResult {
    sql: string;
    values: any[];
}

export declare const findNearestBruteForce: (query: number[], vectors: number[][], k: number) => number[];

export declare const formatTable: (data: any[], columns: string[]) => string;

export declare const generateClusteredVectors: (count: number, dim: number, numClusters?: number) => number[][];

export declare const generateRandomVectors: (count: number, dim: number) => number[][];

export declare const generateSkewedVectors: (count: number, dim: number) => number[][];

export declare const getHNSWConfig: (indexConfig: IndexConfig) => {
    m: number;
    efConstruction: number;
};

export declare function getIndexDescription({ type, hnsw, }: {
    type: IndexType;
    hnsw: {
        m: number;
        efConstruction: number;
    };
}): string;

export declare const getListCount: (indexConfig: IndexConfig, size: number) => number | undefined;

export declare function getSearchEf(k: number, m: number): {
    default: number;
    lower: number;
    higher: number;
};

export declare const groupBy: <T, K extends keyof T>(array: T[], key: K | ((item: T) => string), reducer?: (group: T[]) => any) => Record<string, any>;

export declare const handleKey: (key: string) => string;

declare interface HNSWConfig {
    m?: number;
    efConstruction?: number;
}

export declare interface IndexConfig {
    type?: IndexType;
    ivf?: IVFConfig;
    hnsw?: HNSWConfig;
}

export declare type IndexType = 'ivfflat' | 'hnsw' | 'flat';

declare interface IVFConfig {
    lists?: number;
}

export declare function measureLatency<T>(fn: () => Promise<T>): Promise<[number, T]>;

declare type OperatorFn = (key: string, paramIndex: number, value?: any) => FilterOperator;

export declare type OperatorType = BasicOperator | NumericOperator | ArrayOperator | ElementOperator | LogicalOperator | '$contains' | Exclude<RegexOperator, '$options'>;

declare type PgCreateIndexArgs = [...CreateIndexArgs, IndexConfig?, boolean?];

declare interface PgCreateIndexParams extends CreateIndexParams {
    indexConfig?: IndexConfig;
    buildIndex?: boolean;
}

declare type PgDefineIndexArgs = [string, 'cosine' | 'euclidean' | 'dotproduct', IndexConfig];

declare interface PgDefineIndexParams {
    indexName: string;
    metric: 'cosine' | 'euclidean' | 'dotproduct';
    indexConfig: IndexConfig;
}

/**
 * Translates MongoDB-style filters to PG compatible filters.
 *
 * Key differences from MongoDB:
 *
 * Logical Operators ($and, $or, $nor):
 * - Can be used at the top level or nested within fields
 * - Can take either a single condition or an array of conditions
 *
 */
export declare class PGFilterTranslator extends BaseFilterTranslator {
    protected getSupportedOperators(): OperatorSupport;
    translate(filter?: VectorFilter): VectorFilter;
    private translateNode;
    private translateRegexPattern;
}

declare interface PGIndexStats extends IndexStats {
    type: IndexType;
    config: {
        m?: number;
        efConstruction?: number;
        lists?: number;
        probes?: number;
    };
}
export { PGIndexStats }
export { PGIndexStats as PGIndexStats_alias_1 }

declare type PgQueryVectorArgs = [...QueryVectorArgs, number?, number?, number?];

declare interface PgQueryVectorParams extends QueryVectorParams {
    minScore?: number;
    /**
     * HNSW search parameter. Controls the size of the dynamic candidate
     * list during search. Higher values improve accuracy at the cost of speed.
     */
    ef?: number;
    /**
     * IVFFlat probe parameter. Number of cells to visit during search.
     * Higher values improve accuracy at the cost of speed.
     */
    probes?: number;
}

declare class PgVector extends MastraVector {
    private pool;
    private describeIndexCache;
    private createdIndexes;
    private mutexesByName;
    private schema?;
    private createSchemaPromise;
    constructor(connectionString: string);
    constructor(config: {
        connectionString: string;
        schema?: string;
    });
    private getMutexByName;
    private getTableName;
    transformFilter(filter?: VectorFilter): VectorFilter;
    getIndexInfo(indexName: string): Promise<PGIndexStats>;
    query(...args: ParamsToArgs<PgQueryVectorParams> | PgQueryVectorArgs): Promise<QueryResult[]>;
    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
    private hasher;
    private getIndexCacheKey;
    private cachedIndexExists;
    createIndex(...args: ParamsToArgs<PgCreateIndexParams> | PgCreateIndexArgs): Promise<void>;
    /**
     * @deprecated This function is deprecated. Use buildIndex instead
     */
    defineIndex(indexName: string, metric: "cosine" | "euclidean" | "dotproduct" | undefined, indexConfig: IndexConfig): Promise<void>;
    buildIndex(...args: ParamsToArgs<PgDefineIndexParams> | PgDefineIndexArgs): Promise<void>;
    private setupIndex;
    listIndexes(): Promise<string[]>;
    describeIndex(indexName: string): Promise<PGIndexStats>;
    deleteIndex(indexName: string): Promise<void>;
    truncateIndex(indexName: string): Promise<void>;
    disconnect(): Promise<void>;
    updateIndexById(indexName: string, id: string, update: {
        vector?: number[];
        metadata?: Record<string, any>;
    }): Promise<void>;
    deleteIndexById(indexName: string, id: string): Promise<void>;
}
export { PgVector }
export { PgVector as PgVector_alias_1 }

declare type PostgresConfig = {
    schema?: string;
} & ({
    host: string;
    port: number;
    database: string;
    user: string;
    password: string;
    ssl?: boolean | ISSLConfig;
} | {
    connectionString: string;
});
export { PostgresConfig }
export { PostgresConfig as PostgresConfig_alias_1 }

declare class PostgresStore extends MastraStorage {
    private db;
    private pgp;
    private schema?;
    private createSchemaPromise;
    constructor(config: PostgresConfig);
    private getTableName;
    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
    private transformEvalRow;
    batchInsert({ tableName, records }: {
        tableName: TABLE_NAMES;
        records: Record<string, any>[];
    }): Promise<void>;
    getTraces({ name, scope, page, perPage, attributes, filters, }: {
        name?: string;
        scope?: string;
        page: number;
        perPage: number;
        attributes?: Record<string, string>;
        filters?: Record<string, any>;
    }): Promise<any[]>;
    createTable({ tableName, schema, }: {
        tableName: TABLE_NAMES;
        schema: Record<string, StorageColumn>;
    }): Promise<void>;
    clearTable({ tableName }: {
        tableName: TABLE_NAMES;
    }): Promise<void>;
    insert({ tableName, record }: {
        tableName: TABLE_NAMES;
        record: Record<string, any>;
    }): Promise<void>;
    load<R>({ tableName, keys }: {
        tableName: TABLE_NAMES;
        keys: Record<string, string>;
    }): Promise<R | null>;
    getThreadById({ threadId }: {
        threadId: string;
    }): Promise<StorageThreadType | null>;
    getThreadsByResourceId({ resourceId }: {
        resourceId: string;
    }): Promise<StorageThreadType[]>;
    saveThread({ thread }: {
        thread: StorageThreadType;
    }): Promise<StorageThreadType>;
    updateThread({ id, title, metadata, }: {
        id: string;
        title: string;
        metadata: Record<string, unknown>;
    }): Promise<StorageThreadType>;
    deleteThread({ threadId }: {
        threadId: string;
    }): Promise<void>;
    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T>;
    saveMessages({ messages }: {
        messages: MessageType[];
    }): Promise<MessageType[]>;
    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
        workflowName: string;
        runId: string;
        snapshot: WorkflowRunState;
    }): Promise<void>;
    loadWorkflowSnapshot({ workflowName, runId, }: {
        workflowName: string;
        runId: string;
    }): Promise<WorkflowRunState | null>;
    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, }?: {
        workflowName?: string;
        fromDate?: Date;
        toDate?: Date;
        limit?: number;
        offset?: number;
    }): Promise<{
        runs: Array<{
            workflowName: string;
            runId: string;
            snapshot: WorkflowRunState | string;
            createdAt: Date;
            updatedAt: Date;
        }>;
        total: number;
    }>;
    close(): Promise<void>;
}
export { PostgresStore }
export { PostgresStore as PostgresStore_alias_1 }

export declare interface TestConfig {
    dimension: number;
    size: number;
    k: number;
    queryCount: number;
}

export declare interface TestResult {
    distribution: string;
    dimension: number;
    type: IndexType;
    size: number;
    k?: number;
    metrics: {
        recall?: number;
        minRecall?: number;
        maxRecall?: number;
        latency?: {
            p50: number;
            p95: number;
            lists?: number;
            vectorsPerList?: number;
            m?: number;
            ef?: number;
        };
        clustering?: {
            numLists?: number;
            avgVectorsPerList?: number;
            recommendedLists?: number;
            distribution?: string;
        };
    };
}

export declare function warmupQuery(vectorDB: PgVector, indexName: string, dimension: number, k: number): Promise<void>;

export { }