ydb-qdrant 2.0.0

package/dist/indexing/IndexScheduler.js

@@ -0,0 +1,66 @@
+import { buildVectorIndex } from "../repositories/collectionsRepo.js";
+import { logger } from "../logging/logger.js";
+const QUIET_MS = 10000; // no upserts for 10s => build
+const MIN_POINTS_THRESHOLD = 100; // only rebuild if at least this many points upserted
+const state = {};
+export function notifyUpsert(tableName, count = 1) {
+    const now = Date.now();
+    const s = state[tableName] ?? {
+        lastUpsertMs: 0,
+        pending: false,
+        pointsUpserted: 0,
+    };
+    s.lastUpsertMs = now;
+    s.pointsUpserted += count;
+    state[tableName] = s;
+}
+export function requestIndexBuild(tableName, dimension, distance, vectorType, opts) {
+    const s = state[tableName] ?? {
+        lastUpsertMs: 0,
+        pending: false,
+        pointsUpserted: 0,
+    };
+    state[tableName] = s;
+    if (opts?.force) {
+        logger.info({ tableName }, "index build (force) starting");
+        void buildVectorIndex(tableName, dimension, distance, vectorType)
+            .then(() => {
+            logger.info({ tableName }, "index build (force) completed");
+            s.pointsUpserted = 0;
+        })
+            .catch((err) => {
+            logger.error({ err, tableName }, "index build (force) failed");
+        });
+        return;
+    }
+    if (s.pending && s.timer) {
+        // already scheduled; timer will check quiet window
+        return;
+    }
+    s.pending = true;
+    s.timer = setTimeout(function tryBuild() {
+        const since = Date.now() - (state[tableName]?.lastUpsertMs ?? 0);
+        if (since < QUIET_MS) {
+            s.timer = setTimeout(tryBuild, QUIET_MS - since);
+            return;
+        }
+        const pointsCount = state[tableName]?.pointsUpserted ?? 0;
+        if (pointsCount < MIN_POINTS_THRESHOLD) {
+            logger.info({ tableName, pointsCount, threshold: MIN_POINTS_THRESHOLD }, "index build skipped (below threshold)");
+            s.pending = false;
+            s.timer = undefined;
+            return;
+        }
+        logger.info({ tableName, pointsCount }, "index build (scheduled) starting");
+        void buildVectorIndex(tableName, dimension, distance, vectorType)
+            .then(() => {
+            logger.info({ tableName }, "index build (scheduled) completed");
+            state[tableName].pointsUpserted = 0;
+        })
+            .catch((err) => logger.error({ err, tableName }, "index build (scheduled) failed"))
+            .finally(() => {
+            s.pending = false;
+            s.timer = undefined;
+        });
+    }, QUIET_MS);
+}

package/dist/logging/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from "pino";
+export declare const logger: pino.Logger<never, boolean>;

package/dist/logging/logger.js

@@ -0,0 +1,3 @@
+import pino from "pino";
+import { LOG_LEVEL } from "../config/env.js";
+export const logger = pino({ level: LOG_LEVEL });

package/dist/middleware/requestLogger.d.ts

@@ -0,0 +1,2 @@
+import type { Request, Response, NextFunction } from "express";
+export declare function requestLogger(req: Request, res: Response, next: NextFunction): void;

package/dist/middleware/requestLogger.js

@@ -0,0 +1,14 @@
+import { logger } from "../logging/logger.js";
+export function requestLogger(req, res, next) {
+    const start = Date.now();
+    const tenant = req.header("X-Tenant-Id") ?? "default";
+    const { method, originalUrl } = req;
+    const contentLength = req.header("content-length");
+    const queryKeys = Object.keys(req.query || {});
+    logger.info({ method, url: originalUrl, tenant, contentLength, queryKeys }, "req");
+    res.on("finish", () => {
+        const ms = Date.now() - start;
+        logger.info({ method, url: originalUrl, tenant, status: res.statusCode, ms }, "res");
+    });
+    next();
+}

package/dist/repositories/collectionsRepo.d.ts

@@ -0,0 +1,10 @@
+import type { DistanceKind, VectorType } from "../types";
+export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string): Promise<void>;
+export declare function getCollectionMeta(metaKey: string): Promise<{
+    table: string;
+    dimension: number;
+    distance: DistanceKind;
+    vectorType: VectorType;
+} | null>;
+export declare function deleteCollection(metaKey: string): Promise<void>;
+export declare function buildVectorIndex(tableName: string, dimension: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;

package/dist/repositories/collectionsRepo.js

@@ -0,0 +1,118 @@
+import { Types, TypedValues, withSession, TableDescription, Column, } from "../ydb/client.js";
+export async function createCollection(metaKey, dim, distance, vectorType, tableName) {
+    await withSession(async (s) => {
+        const desc = new TableDescription()
+            .withColumns(new Column("point_id", Types.UTF8), new Column("embedding", Types.BYTES), new Column("payload", Types.JSON_DOCUMENT))
+            .withPrimaryKey("point_id");
+        await s.createTable(tableName, desc);
+    });
+    const upsertMeta = `
+    DECLARE $collection AS Utf8;
+    DECLARE $table AS Utf8;
+    DECLARE $dim AS Uint32;
+    DECLARE $distance AS Utf8;
+    DECLARE $vtype AS Utf8;
+    DECLARE $created AS Timestamp;
+    UPSERT INTO qdr__collections (collection, table_name, vector_dimension, distance, vector_type, created_at)
+    VALUES ($collection, $table, $dim, $distance, $vtype, $created);
+  `;
+    await withSession(async (s) => {
+        await s.executeQuery(upsertMeta, {
+            $collection: TypedValues.utf8(metaKey),
+            $table: TypedValues.utf8(tableName),
+            $dim: TypedValues.uint32(dim),
+            $distance: TypedValues.utf8(distance),
+            $vtype: TypedValues.utf8(vectorType),
+            $created: TypedValues.timestamp(new Date()),
+        });
+    });
+}
+export async function getCollectionMeta(metaKey) {
+    const qry = `
+    DECLARE $collection AS Utf8;
+    SELECT table_name, vector_dimension, distance, vector_type
+    FROM qdr__collections
+    WHERE collection = $collection;
+  `;
+    const res = await withSession(async (s) => {
+        return await s.executeQuery(qry, {
+            $collection: TypedValues.utf8(metaKey),
+        });
+    });
+    const rowset = res.resultSets?.[0];
+    if (!rowset || rowset.rows?.length !== 1)
+        return null;
+    const row = rowset.rows[0];
+    const table = row.items?.[0]?.textValue;
+    const dimension = Number(row.items?.[1]?.uint32Value ?? row.items?.[1]?.textValue);
+    const distance = row.items?.[2]?.textValue ?? "Cosine";
+    const vectorType = row.items?.[3]?.textValue ?? "float";
+    return { table, dimension, distance, vectorType };
+}
+export async function deleteCollection(metaKey) {
+    const meta = await getCollectionMeta(metaKey);
+    if (!meta)
+        return;
+    await withSession(async (s) => {
+        await s.dropTable(meta.table);
+    });
+    const delMeta = `
+    DECLARE $collection AS Utf8;
+    DELETE FROM qdr__collections WHERE collection = $collection;
+  `;
+    await withSession(async (s) => {
+        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) });
+    });
+}
+export async function buildVectorIndex(tableName, dimension, distance, vectorType) {
+    const distParam = mapDistanceToIndexParam(distance);
+    // defaults for <100k vectors
+    const levels = 1;
+    const clusters = 128;
+    await withSession(async (s) => {
+        // Drop existing index if present
+        const dropDdl = `ALTER TABLE ${tableName} DROP INDEX emb_idx;`;
+        try {
+            const dropReq = { sessionId: s.sessionId, yqlText: dropDdl };
+            await s.api.executeSchemeQuery(dropReq);
+        }
+        catch (e) {
+            const msg = String(e?.message ?? e);
+            // ignore if index doesn't exist
+            if (!/not found|does not exist|no such index/i.test(msg)) {
+                throw e;
+            }
+        }
+        // Create new index
+        const createDdl = `
+      ALTER TABLE ${tableName}
+      ADD INDEX emb_idx GLOBAL SYNC USING vector_kmeans_tree
+      ON (embedding)
+      WITH (
+        ${distParam === "inner_product"
+            ? `similarity="inner_product"`
+            : `distance="${distParam}"`},
+        vector_type="${vectorType}",
+        vector_dimension=${dimension},
+        clusters=${clusters},
+        levels=${levels}
+      );
+    `;
+        const createReq = { sessionId: s.sessionId, yqlText: createDdl };
+        await s.api.executeSchemeQuery(createReq);
+    });
+}
+function mapDistanceToIndexParam(distance) {
+    switch (distance) {
+        case "Cosine":
+            return "cosine";
+        case "Dot":
+            return "inner_product";
+        case "Euclid":
+            return "euclidean";
+        case "Manhattan":
+            return "manhattan";
+        default:
+            return "cosine";
+    }
+}

package/dist/repositories/pointsRepo.d.ts

@@ -0,0 +1,12 @@
+import type { VectorType, DistanceKind } from "../types";
+export declare function upsertPoints(tableName: string, points: Array<{
+    id: string | number;
+    vector: number[];
+    payload?: Record<string, unknown>;
+}>, vectorType: VectorType, dimension: number): Promise<number>;
+export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, vectorType: VectorType, dimension: number): Promise<Array<{
+    id: string;
+    score: number;
+    payload?: Record<string, unknown>;
+}>>;
+export declare function deletePoints(tableName: string, ids: Array<string | number>): Promise<number>;

package/dist/repositories/pointsRepo.js

@@ -0,0 +1,151 @@
+import { TypedValues, withSession } from "../ydb/client.js";
+import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
+import { logger } from "../logging/logger.js";
+import { APPROX_PRESELECT } from "../config/env.js";
+import { notifyUpsert } from "../indexing/IndexScheduler.js";
+export async function upsertPoints(tableName, points, vectorType, dimension) {
+    let upserted = 0;
+    await withSession(async (s) => {
+        for (const p of points) {
+            const id = String(p.id);
+            if (p.vector.length !== dimension) {
+                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
+            }
+            const ddl = `
+        DECLARE $id AS Utf8;
+        DECLARE $vec AS List<${vectorType === "uint8" ? "Uint8" : "Float"}>;
+        DECLARE $payload AS JsonDocument;
+        UPSERT INTO ${tableName} (point_id, embedding, payload)
+        VALUES (
+          $id,
+          Untag(Knn::ToBinaryString${vectorType === "uint8" ? "Uint8" : "Float"}($vec), "${vectorType === "uint8" ? "Uint8Vector" : "FloatVector"}"),
+          $payload
+        );
+      `;
+            const params = {
+                $id: TypedValues.utf8(id),
+                $vec: buildVectorParam(p.vector, vectorType),
+                $payload: buildJsonOrEmpty(p.payload),
+            };
+            // Retry on transient schema/metadata mismatches during index rebuild
+            const maxRetries = 6; // ~ up to ~ (0.25 + jitter) * 2^5 ≈ few seconds
+            let attempt = 0;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                try {
+                    await s.executeQuery(ddl, params);
+                    break;
+                }
+                catch (e) {
+                    const msg = String(e?.message ?? e);
+                    const isTransient = /Aborted|schema version mismatch|Table metadata loading|Failed to load metadata/i.test(msg);
+                    if (!isTransient || attempt >= maxRetries) {
+                        throw e;
+                    }
+                    const backoffMs = Math.floor(250 * Math.pow(2, attempt) + Math.random() * 100);
+                    logger.warn({ tableName, id, attempt, backoffMs }, "upsert aborted due to schema/metadata change; retrying");
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    attempt += 1;
+                }
+            }
+            upserted += 1;
+        }
+    });
+    // notify scheduler for potential end-of-batch index build
+    notifyUpsert(tableName, upserted);
+    // No index rebuild; approximate search does not require it
+    return upserted;
+}
+// Removed legacy index backfill helper
+export async function searchPoints(tableName, queryVector, top, withPayload, distance, vectorType, dimension) {
+    if (queryVector.length !== dimension) {
+        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
+    }
+    const { fn, order } = mapDistanceToKnnFn(distance);
+    // Single-phase search over embedding using vector index if present
+    const preselect = Math.min(APPROX_PRESELECT, Math.max(top * 10, top));
+    const qf = buildVectorParam(queryVector, vectorType);
+    const params = {
+        $qf: qf,
+        $k2: TypedValues.uint32(top),
+    };
+    const buildQuery = (useIndex) => `
+    DECLARE $qf AS List<${vectorType === "uint8" ? "Uint8" : "Float"}>;
+    DECLARE $k2 AS Uint32;
+    $qbinf = Knn::ToBinaryString${vectorType === "uint8" ? "Uint8" : "Float"}($qf);
+    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+    FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
+    ORDER BY score ${order}
+    LIMIT $k2;
+  `;
+    let rs;
+    try {
+        // Try with vector index first
+        rs = await withSession(async (s) => {
+            return await s.executeQuery(buildQuery(true), params);
+        });
+        logger.info({ tableName }, "vector index found; using index for search");
+    }
+    catch (e) {
+        const msg = String(e?.message ?? e);
+        // Fallback to table scan if index not found or not ready
+        if (/not found|does not exist|no such index|no global index|is not ready to use/i.test(msg)) {
+            logger.info({ tableName }, "vector index not available (missing or building); falling back to table scan");
+            rs = await withSession(async (s) => {
+                return await s.executeQuery(buildQuery(false), params);
+            });
+        }
+        else {
+            throw e;
+        }
+    }
+    const rowset = rs.resultSets?.[0];
+    const rows = (rowset?.rows ?? []);
+    return rows.map((row) => {
+        const id = row.items?.[0]?.textValue;
+        let payload;
+        let scoreIdx = 1;
+        if (withPayload) {
+            const payloadText = row.items?.[1]?.textValue;
+            if (payloadText) {
+                try {
+                    payload = JSON.parse(payloadText);
+                }
+                catch {
+                    payload = undefined;
+                }
+            }
+            scoreIdx = 2;
+        }
+        const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
+        return { id, score, ...(payload ? { payload } : {}) };
+    });
+}
+export async function deletePoints(tableName, ids) {
+    let deleted = 0;
+    await withSession(async (s) => {
+        for (const id of ids) {
+            const yql = `
+        DECLARE $id AS Utf8;
+        DELETE FROM ${tableName} WHERE point_id = $id;
+      `;
+            await s.executeQuery(yql, { $id: TypedValues.utf8(String(id)) });
+            deleted += 1;
+        }
+    });
+    return deleted;
+}
+function mapDistanceToKnnFn(distance) {
+    switch (distance) {
+        case "Cosine":
+            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+        case "Dot":
+            return { fn: "Knn::InnerProductSimilarity", order: "DESC" };
+        case "Euclid":
+            return { fn: "Knn::EuclideanDistance", order: "ASC" };
+        case "Manhattan":
+            return { fn: "Knn::ManhattanDistance", order: "ASC" };
+        default:
+            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+    }
+}

package/dist/routes/collections.d.ts

@@ -0,0 +1 @@
+export declare const collectionsRouter: import("express-serve-static-core").Router;

package/dist/routes/collections.js

@@ -0,0 +1,74 @@
+import { Router } from "express";
+import { sanitizeCollectionName, sanitizeTenantId } from "../utils/tenant.js";
+import { QdrantServiceError, putCollectionIndex, createCollection, getCollection, deleteCollection, } from "../services/QdrantService.js";
+import { logger } from "../logging/logger.js";
+export const collectionsRouter = Router();
+collectionsRouter.put("/:collection/index", async (req, res) => {
+    try {
+        const result = await putCollectionIndex({
+            tenant: req.header("X-Tenant-Id") ?? undefined,
+            collection: String(req.params.collection),
+        });
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "build index failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+collectionsRouter.put("/:collection", async (req, res) => {
+    try {
+        const tenant = sanitizeTenantId(req.header("X-Tenant-Id") ?? "default");
+        const collection = sanitizeCollectionName(String(req.params.collection));
+        const result = await createCollection({ tenant, collection }, req.body);
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "create collection failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+collectionsRouter.get("/:collection", async (req, res) => {
+    try {
+        const tenant = sanitizeTenantId(req.header("X-Tenant-Id") ?? "default");
+        const collection = sanitizeCollectionName(String(req.params.collection));
+        const result = await getCollection({ tenant, collection });
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "get collection failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+collectionsRouter.delete("/:collection", async (req, res) => {
+    try {
+        const tenant = sanitizeTenantId(req.header("X-Tenant-Id") ?? "default");
+        const collection = sanitizeCollectionName(String(req.params.collection));
+        const result = await deleteCollection({ tenant, collection });
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "delete collection failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});

package/dist/routes/points.d.ts

@@ -0,0 +1 @@
+export declare const pointsRouter: import("express-serve-static-core").Router;

package/dist/routes/points.js

@@ -0,0 +1,96 @@
+import { Router } from "express";
+import { QdrantServiceError, upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/QdrantService.js";
+import { logger } from "../logging/logger.js";
+export const pointsRouter = Router();
+// Qdrant-compatible: PUT /collections/:collection/points (upsert)
+pointsRouter.put("/:collection/points", async (req, res) => {
+    try {
+        const result = await upsertPoints({
+            tenant: req.header("X-Tenant-Id") ?? undefined,
+            collection: String(req.params.collection),
+        }, req.body);
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "upsert points (PUT) failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+pointsRouter.post("/:collection/points/upsert", async (req, res) => {
+    try {
+        const result = await upsertPoints({
+            tenant: req.header("X-Tenant-Id") ?? undefined,
+            collection: String(req.params.collection),
+        }, req.body);
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "upsert points failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+pointsRouter.post("/:collection/points/search", async (req, res) => {
+    try {
+        const result = await searchPoints({
+            tenant: req.header("X-Tenant-Id") ?? undefined,
+            collection: String(req.params.collection),
+        }, req.body);
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "search points failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+// Compatibility: some clients call POST /collections/:collection/points/query
+pointsRouter.post("/:collection/points/query", async (req, res) => {
+    try {
+        const result = await queryPoints({
+            tenant: req.header("X-Tenant-Id") ?? undefined,
+            collection: String(req.params.collection),
+        }, req.body);
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "search points (query) failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});
+pointsRouter.post("/:collection/points/delete", async (req, res) => {
+    try {
+        const result = await deletePoints({
+            tenant: req.header("X-Tenant-Id") ?? undefined,
+            collection: String(req.params.collection),
+        }, req.body);
+        res.json({ status: "ok", result });
+    }
+    catch (err) {
+        if (err instanceof QdrantServiceError) {
+            return res.status(err.statusCode).json(err.payload);
+        }
+        logger.error({ err }, "delete points failed");
+        res
+            .status(500)
+            .json({ status: "error", error: String(err?.message ?? err) });
+    }
+});

package/dist/server.d.ts

@@ -0,0 +1 @@
+export declare function buildServer(): import("express-serve-static-core").Express;

package/dist/server.js

@@ -0,0 +1,13 @@
+import express from "express";
+import { collectionsRouter } from "./routes/collections.js";
+import { pointsRouter } from "./routes/points.js";
+import { requestLogger } from "./middleware/requestLogger.js";
+export function buildServer() {
+    const app = express();
+    app.use(express.json({ limit: "20mb" }));
+    app.use(requestLogger);
+    app.get("/health", (_req, res) => res.json({ status: "ok" }));
+    app.use("/collections", collectionsRouter);
+    app.use("/collections", pointsRouter);
+    return app;
+}

package/dist/services/QdrantService.d.ts

@@ -0,0 +1,55 @@
+import { type DistanceKind } from "../types.js";
+export interface QdrantServiceErrorPayload {
+    status: "error";
+    error: unknown;
+}
+export declare class QdrantServiceError extends Error {
+    readonly statusCode: number;
+    readonly payload: QdrantServiceErrorPayload;
+    constructor(statusCode: number, payload: QdrantServiceErrorPayload, message?: string);
+}
+interface CollectionContextInput {
+    tenant: string | undefined;
+    collection: string;
+}
+export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
+    acknowledged: boolean;
+}>;
+export declare function createCollection(ctx: CollectionContextInput, body: unknown): Promise<{
+    name: string;
+    tenant: string;
+}>;
+export declare function getCollection(ctx: CollectionContextInput): Promise<{
+    name: string;
+    vectors: {
+        size: number;
+        distance: DistanceKind;
+        data_type: string;
+    };
+}>;
+export declare function deleteCollection(ctx: CollectionContextInput): Promise<{
+    acknowledged: boolean;
+}>;
+interface PointsContextInput extends CollectionContextInput {
+}
+export declare function upsertPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    upserted: number;
+}>;
+export declare function searchPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: Array<{
+        id: string;
+        score: number;
+        payload?: Record<string, unknown>;
+    }>;
+}>;
+export declare function queryPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: Array<{
+        id: string;
+        score: number;
+        payload?: Record<string, unknown>;
+    }>;
+}>;
+export declare function deletePoints(ctx: PointsContextInput, body: unknown): Promise<{
+    deleted: number;
+}>;
+export {};