ydb-qdrant 6.0.0 → 8.1.0

package/dist/services/PointsService.js

@@ -1,12 +1,68 @@
 import { UpsertPointsReq, SearchReq, DeletePointsReq } from "../types.js";
 import { ensureMetaTable } from "../ydb/schema.js";
 import { getCollectionMeta, touchCollectionLastAccess, } from "../repositories/collectionsRepo.js";
-import { deletePoints as repoDeletePoints, searchPoints as repoSearchPoints, upsertPoints as repoUpsertPoints, } from "../repositories/pointsRepo.js";
+import { deletePoints as repoDeletePoints, deletePointsByPathSegments as repoDeletePointsByPathSegments, searchPoints as repoSearchPoints, upsertPoints as repoUpsertPoints, } from "../repositories/pointsRepo.js";
 import { logger } from "../logging/logger.js";
 import { QdrantServiceError, isVectorDimensionMismatchError, } from "./errors.js";
 import { normalizeCollectionContextShared } from "./CollectionService.shared.js";
 import { resolvePointsTableAndUidOneTable } from "./CollectionService.one-table.js";
 import { normalizeSearchBodyForSearch, normalizeSearchBodyForQuery, } from "../utils/normalization.js";
+function parsePathSegmentsFilterToPaths(filter) {
+    const extractMust = (must) => {
+        if (!Array.isArray(must) || must.length === 0)
+            return null;
+        const pairs = [];
+        for (const cond of must) {
+            if (typeof cond !== "object" || cond === null)
+                return null;
+            const c = cond;
+            if (typeof c.key !== "string")
+                return null;
+            const m = /^pathSegments\.(\d+)$/.exec(c.key);
+            if (!m)
+                return null;
+            const idx = Number(m[1]);
+            if (!Number.isInteger(idx) || idx < 0)
+                return null;
+            if (typeof c.match !== "object" || c.match === null)
+                return null;
+            const match = c.match;
+            if (typeof match.value !== "string")
+                return null;
+            pairs.push({ idx, value: match.value });
+        }
+        pairs.sort((a, b) => a.idx - b.idx);
+        // Require contiguous indexes starting from 0 to avoid ambiguous matches.
+        for (let i = 0; i < pairs.length; i += 1) {
+            if (pairs[i].idx !== i)
+                return null;
+        }
+        return pairs.map((p) => p.value);
+    };
+    if (typeof filter !== "object" || filter === null)
+        return null;
+    const f = filter;
+    if (f.must !== undefined) {
+        const path = extractMust(f.must);
+        return path ? [path] : null;
+    }
+    if (f.should !== undefined) {
+        if (!Array.isArray(f.should) || f.should.length === 0)
+            return null;
+        const paths = [];
+        for (const g of f.should) {
+            if (typeof g !== "object" || g === null)
+                return null;
+            const group = g;
+            const path = extractMust(group.must);
+            if (!path)
+                return null;
+            paths.push(path);
+        }
+        return paths;
+    }
+    return null;
+}
 export async function upsertPoints(ctx, body) {
     await ensureMetaTable();
     const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
@@ -89,9 +145,10 @@ async function executeSearch(ctx, normalizedSearch, source) {
         distance: meta.distance,
         vectorType: meta.vectorType,
     }, `${source}: executing`);
+    const filterPaths = parsePathSegmentsFilterToPaths(normalizedSearch.filter);
     let hits;
     try {
-        hits = await repoSearchPoints(tableName, parsed.data.vector, parsed.data.top, parsed.data.with_payload, meta.distance, meta.dimension, uid);
+        hits = await repoSearchPoints(tableName, parsed.data.vector, parsed.data.top, parsed.data.with_payload, meta.distance, meta.dimension, uid, filterPaths ?? undefined);
     }
     catch (err) {
         if (isVectorDimensionMismatchError(err)) {
@@ -163,7 +220,20 @@ export async function deletePoints(ctx, body) {
         });
     }
     const { tableName, uid } = await resolvePointsTableAndUidOneTable(normalized);
-    const deleted = await repoDeletePoints(tableName, parsed.data.points, uid);
+    let deleted;
+    if ("points" in parsed.data) {
+        deleted = await repoDeletePoints(tableName, parsed.data.points, uid);
+    }
+    else {
+        const paths = parsePathSegmentsFilterToPaths(parsed.data.filter);
+        if (!paths) {
+            throw new QdrantServiceError(400, {
+                status: "error",
+                error: "unsupported delete filter: only pathSegments.N match filters with must/should are supported",
+            });
+        }
+        deleted = await repoDeletePointsByPathSegments(tableName, uid, paths);
+    }
     await touchCollectionLastAccess(normalized.metaKey);
     return { deleted };
 }

package/dist/types.d.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
-export type DistanceKind = "Cosine" | "Euclid" | "Dot" | "Manhattan";
+import type { QdrantDistance, QdrantPayload, QdrantWithPayloadInterface, YdbQdrantPointId, YdbQdrantUpsertPoint } from "./qdrant/QdrantRestTypes.js";
+export type DistanceKind = QdrantDistance;
 export type VectorType = "float";
+export type Payload = QdrantPayload;
+export type WithPayload = QdrantWithPayloadInterface;
 /**
  * Collection metadata from qdr__collections table.
  *
@@ -25,16 +28,67 @@ export declare const CreateCollectionReq: z.ZodObject<{
 }, z.core.$strip>;
 export declare const UpsertPointsReq: z.ZodObject<{
     points: z.ZodArray<z.ZodObject<{
-        id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        id: z.ZodType<YdbQdrantPointId>;
         vector: z.ZodArray<z.ZodNumber>;
-        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        payload: z.ZodType<Payload | undefined>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+export type UpsertPoint = YdbQdrantUpsertPoint;
+export type UpsertPointsBody = {
+    points: UpsertPoint[];
+};
 export declare const SearchReq: z.ZodObject<{
     vector: z.ZodArray<z.ZodNumber>;
     top: z.ZodNumber;
     with_payload: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-export declare const DeletePointsReq: z.ZodObject<{
-    points: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+export type SearchPointsBody = {
+    vector: number[];
+    top?: number;
+    limit?: number;
+    with_payload?: WithPayload;
+    score_threshold?: number | null;
+};
+export declare const DeletePointsByIdsReq: z.ZodObject<{
+    points: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
 }, z.core.$strip>;
+export declare const DeletePointsByFilterReq: z.ZodObject<{
+    filter: z.ZodUnion<readonly [z.ZodObject<{
+        must: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            match: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        should: z.ZodArray<z.ZodObject<{
+            must: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                match: z.ZodObject<{
+                    value: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export declare const DeletePointsReq: z.ZodUnion<readonly [z.ZodObject<{
+    points: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
+}, z.core.$strip>, z.ZodObject<{
+    filter: z.ZodUnion<readonly [z.ZodObject<{
+        must: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            match: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        should: z.ZodArray<z.ZodObject<{
+            must: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                match: z.ZodObject<{
+                    value: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>]>;

package/dist/types.js

@@ -16,7 +16,7 @@ export const UpsertPointsReq = z.object({
         .array(z.object({
         id: z.union([z.string(), z.number()]),
         vector: z.array(z.number()),
-        payload: z.record(z.string(), z.any()).optional(),
+        payload: z.record(z.string(), z.unknown()).optional(),
     }))
         .min(1),
 });
@@ -25,6 +25,30 @@ export const SearchReq = z.object({
     top: z.number().int().positive().max(1000),
     with_payload: z.boolean().optional(),
 });
-export const DeletePointsReq = z.object({
-    points: z.array(z.union([z.string(), z.number()])).min(1),
+export const DeletePointsByIdsReq = z.object({
+    points: z
+        .array(z.union([z.string(), z.number()]))
+        .min(1),
+});
+const DeletePointsFilterCondition = z.object({
+    key: z.string(),
+    match: z.object({
+        value: z.string(),
+    }),
+});
+const DeletePointsFilterMust = z.object({
+    must: z.array(DeletePointsFilterCondition).min(1),
+});
+const DeletePointsFilter = z.union([
+    DeletePointsFilterMust,
+    z.object({
+        should: z.array(DeletePointsFilterMust).min(1),
+    }),
+]);
+export const DeletePointsByFilterReq = z.object({
+    filter: DeletePointsFilter,
 });
+export const DeletePointsReq = z.union([
+    DeletePointsByIdsReq,
+    DeletePointsByFilterReq,
+]);

package/dist/utils/normalization.d.ts

@@ -3,6 +3,7 @@ export interface SearchNormalizationResult {
     top: number | undefined;
     withPayload: boolean | undefined;
     scoreThreshold: number | undefined;
+    filter?: unknown;
 }
 export declare function isNumberArray(value: unknown): value is number[];
 export declare function extractVectorLoose(body: unknown, depth?: number): number[] | undefined;

package/dist/utils/normalization.js

@@ -74,6 +74,7 @@ function normalizeSearchCommon(b, vector) {
     const topFromTop = typeof rawTop === "number" ? rawTop : undefined;
     const topFromLimit = typeof rawLimit === "number" ? rawLimit : undefined;
     const top = topFromTop ?? topFromLimit;
+    const filter = b["filter"];
     let withPayload;
     const rawWithPayload = b["with_payload"];
     if (typeof rawWithPayload === "boolean") {
@@ -88,5 +89,5 @@ function normalizeSearchCommon(b, vector) {
     const scoreThreshold = Number.isFinite(thresholdValue)
         ? thresholdValue
         : undefined;
-    return { vector, top, withPayload, scoreThreshold };
+    return { vector, top, withPayload, scoreThreshold, filter };
 }

package/dist/utils/vectorBinary.js

@@ -1,3 +1,4 @@
+const IS_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([0x00ff]).buffer)[0] === 0xff;
 export function vectorToFloatBinary(vector) {
     if (vector.length === 0) {
         return Buffer.from([1]);
@@ -8,28 +9,111 @@ export function vectorToFloatBinary(vector) {
         if (!Number.isFinite(value)) {
             throw new Error(`Non-finite value in vector at index ${i}: ${value}`);
         }
-        buffer.writeFloatLE(value, i * 4);
+        if (IS_LITTLE_ENDIAN) {
+            buffer.writeFloatLE(value, i * 4);
+        }
+        else {
+            buffer.writeFloatBE(value, i * 4);
+        }
     }
     buffer.writeUInt8(1, vector.length * 4);
     return buffer;
 }
 export function vectorToBitBinary(vector) {
-    if (vector.length === 0) {
-        return Buffer.from([10]);
-    }
-    const byteCount = Math.ceil(vector.length / 8);
-    const buffer = Buffer.alloc(byteCount + 1);
+    // Mirrors YDB's TKnnBitVectorSerializer (Knn::ToBinaryStringBit) layout:
+    // - Packed bits as integers written in native endianness
+    // - Then 1 byte: count of unused bits in the last data byte
+    // - Then 1 byte: format marker (10 = BitVector)
+    //
+    // Source: https://raw.githubusercontent.com/ydb-platform/ydb/0b506f56e399e0b4e6a6a4267799da68a3164bf7/ydb/library/yql/udfs/common/knn/knn-serializer.h
+    const bitLen = vector.length;
+    const dataByteLen = Math.ceil(bitLen / 8);
+    const totalLen = dataByteLen + 2; // +1 unused-bit-count +1 format marker
+    const buffer = Buffer.alloc(totalLen);
+    let offset = 0;
+    const writeU64 = (v) => {
+        if (IS_LITTLE_ENDIAN) {
+            buffer.writeBigUInt64LE(v, offset);
+        }
+        else {
+            buffer.writeBigUInt64BE(v, offset);
+        }
+        offset += 8;
+    };
+    const writeU32 = (v) => {
+        if (IS_LITTLE_ENDIAN) {
+            buffer.writeUInt32LE(v, offset);
+        }
+        else {
+            buffer.writeUInt32BE(v, offset);
+        }
+        offset += 4;
+    };
+    const writeU16 = (v) => {
+        if (IS_LITTLE_ENDIAN) {
+            buffer.writeUInt16LE(v, offset);
+        }
+        else {
+            buffer.writeUInt16BE(v, offset);
+        }
+        offset += 2;
+    };
+    const writeU8 = (v) => {
+        buffer.writeUInt8(v, offset);
+        offset += 1;
+    };
+    let accumulator = 0n;
+    let filledBits = 0;
     for (let i = 0; i < vector.length; i += 1) {
         const value = vector[i];
         if (!Number.isFinite(value)) {
             throw new Error(`Non-finite value in vector at index ${i}: ${value}`);
         }
         if (value > 0) {
-            const byteIndex = Math.floor(i / 8);
-            const bitIndex = i % 8;
-            buffer[byteIndex] |= 1 << bitIndex;
+            accumulator |= 1n;
         }
+        filledBits += 1;
+        if (filledBits === 64) {
+            writeU64(accumulator);
+            accumulator = 0n;
+            filledBits = 0;
+        }
+        accumulator <<= 1n;
     }
-    buffer.writeUInt8(10, byteCount);
+    accumulator >>= 1n;
+    filledBits += 7;
+    const tailWriteIf = (bits) => {
+        if (filledBits < bits) {
+            return;
+        }
+        if (bits === 64) {
+            writeU64(accumulator & 0xffffffffffffffffn);
+            filledBits -= 64;
+            return;
+        }
+        if (bits === 32) {
+            writeU32(Number(accumulator & 0xffffffffn));
+            accumulator >>= 32n;
+            filledBits -= 32;
+            return;
+        }
+        if (bits === 16) {
+            writeU16(Number(accumulator & 0xffffn));
+            accumulator >>= 16n;
+            filledBits -= 16;
+            return;
+        }
+        writeU8(Number(accumulator & 0xffn));
+        accumulator >>= 8n;
+        filledBits -= 8;
+    };
+    tailWriteIf(64);
+    tailWriteIf(32);
+    tailWriteIf(16);
+    tailWriteIf(8);
+    // After tail writes, we must have < 8 "filledBits" left.
+    const unusedBitsInLastByte = 7 - filledBits;
+    writeU8(unusedBitsInLastByte);
+    writeU8(10);
     return buffer;
 }

package/dist/ydb/bootstrapMetaTable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates the qdr__collections metadata table if it does not exist.
+ *
+ * Intended for CI and local dev environments where a fresh YDB is provisioned
+ * and schema creation is handled out-of-band from `ensureMetaTable()`.
+ */
+export declare function bootstrapMetaTable(): Promise<void>;

package/dist/ydb/bootstrapMetaTable.js

@@ -0,0 +1,75 @@
+import { Column, TableDescription, Types, destroyDriver, readyOrThrow, withSession, } from "./client.js";
+function isTableNotFoundError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return (/table.*not found/i.test(msg) ||
+        /path.*not found/i.test(msg) ||
+        /does not exist/i.test(msg) ||
+        /NotFound\s*\(code\s*400140\)/i.test(msg) ||
+        (/SchemeError\s*\(code\s*400070\)/i.test(msg) &&
+            /:\s*\[\s*\]\s*$/i.test(msg)));
+}
+function isAlreadyExistsError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /already exists/i.test(msg) || /path.*exists/i.test(msg);
+}
+/**
+ * Creates the qdr__collections metadata table if it does not exist.
+ *
+ * Intended for CI and local dev environments where a fresh YDB is provisioned
+ * and schema creation is handled out-of-band from `ensureMetaTable()`.
+ */
+export async function bootstrapMetaTable() {
+    await readyOrThrow();
+    await withSession(async (s) => {
+        let desc = null;
+        try {
+            desc = await s.describeTable("qdr__collections");
+        }
+        catch (err) {
+            if (!isTableNotFoundError(err)) {
+                throw err;
+            }
+            const td = new TableDescription()
+                .withColumns(new Column("collection", Types.UTF8), new Column("table_name", Types.UTF8), new Column("vector_dimension", Types.UINT32), new Column("distance", Types.UTF8), new Column("vector_type", Types.UTF8), new Column("created_at", Types.TIMESTAMP), new Column("last_accessed_at", Types.TIMESTAMP))
+                .withPrimaryKey("collection");
+            try {
+                await s.createTable("qdr__collections", td);
+                console.log("bootstrapMetaTable: created qdr__collections");
+            }
+            catch (createErr) {
+                if (!isAlreadyExistsError(createErr)) {
+                    throw createErr;
+                }
+            }
+            desc = await s.describeTable("qdr__collections");
+        }
+        const cols = desc?.columns ?? [];
+        const hasLastAccessedAt = cols.some((c) => c.name === "last_accessed_at");
+        if (!hasLastAccessedAt) {
+            throw new Error("bootstrapMetaTable: qdr__collections exists but is missing required column last_accessed_at");
+        }
+    });
+}
+// CLI entrypoint
+if (process.argv[1]?.endsWith("bootstrapMetaTable.js")) {
+    const main = async () => {
+        await bootstrapMetaTable();
+        // Important: ydb-sdk driver/session pool keeps timers alive; explicitly
+        // destroy it so this script can terminate in CI steps.
+        await destroyDriver();
+    };
+    main()
+        .then(() => {
+        process.exit(0);
+    })
+        .catch(async (err) => {
+        console.error(err);
+        try {
+            await destroyDriver();
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        process.exit(1);
+    });
+}

package/dist/ydb/client.d.ts

@@ -1,6 +1,6 @@
-import type { Session, IAuthService, ExecuteQuerySettings as YdbExecuteQuerySettings } from "ydb-sdk";
-declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column, ExecuteQuerySettings: typeof YdbExecuteQuerySettings, Ydb: typeof import("ydb-sdk-proto").Ydb;
-export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, Ydb, };
+import type { Session, IAuthService, ExecuteQuerySettings as YdbExecuteQuerySettings, BulkUpsertSettings as YdbBulkUpsertSettings, QuerySession } from "ydb-sdk";
+declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column, ExecuteQuerySettings: typeof YdbExecuteQuerySettings, BulkUpsertSettings: typeof YdbBulkUpsertSettings, Ydb: typeof import("ydb-sdk-proto").Ydb;
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
 export declare function createExecuteQuerySettings(options?: {
     keepInCache?: boolean;
     idempotent?: boolean;
@@ -10,6 +10,9 @@ export declare function createExecuteQuerySettingsWithTimeout(options: {
     idempotent?: boolean;
     timeoutMs: number;
 }): YdbExecuteQuerySettings;
+export declare function createBulkUpsertSettingsWithTimeout(options: {
+    timeoutMs: number;
+}): YdbBulkUpsertSettings;
 type DriverConfig = {
     endpoint?: string;
     database?: string;
@@ -23,6 +26,10 @@ export declare function __resetRefreshStateForTests(): void;
 export declare function configureDriver(config: DriverConfig): void;
 export declare function readyOrThrow(): Promise<void>;
 export declare function withSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
+export declare function withQuerySession<T>(fn: (s: QuerySession) => Promise<T>, options?: {
+    timeoutMs?: number;
+    idempotent?: boolean;
+}): Promise<T>;
 export declare function withStartupProbeSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
 export declare function isYdbAvailable(timeoutMs?: number): Promise<boolean>;
 /**

package/dist/ydb/client.js

@@ -2,8 +2,8 @@ import { createRequire } from "module";
 import { YDB_DATABASE, YDB_ENDPOINT, SESSION_POOL_MIN_SIZE, SESSION_POOL_MAX_SIZE, SESSION_KEEPALIVE_PERIOD_MS, STARTUP_PROBE_SESSION_TIMEOUT_MS, } from "../config/env.js";
 import { logger } from "../logging/logger.js";
 const require = createRequire(import.meta.url);
-const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, OperationParams, Ydb, } = require("ydb-sdk");
-export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, Ydb, };
+const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, OperationParams, Ydb, } = require("ydb-sdk");
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
 export function createExecuteQuerySettings(options) {
     const { keepInCache = true, idempotent = true } = options ?? {};
     const settings = new ExecuteQuerySettings();
@@ -26,6 +26,15 @@ export function createExecuteQuerySettingsWithTimeout(options) {
     settings.withOperationParams(op);
     return settings;
 }
+export function createBulkUpsertSettingsWithTimeout(options) {
+    const settings = new BulkUpsertSettings();
+    const op = new OperationParams();
+    const seconds = Math.max(1, Math.ceil(options.timeoutMs / 1000));
+    op.withOperationTimeoutSeconds(seconds);
+    op.withCancelAfterSeconds(seconds);
+    settings.withOperationParams(op);
+    return settings;
+}
 const DRIVER_READY_TIMEOUT_MS = 15000;
 const TABLE_SESSION_TIMEOUT_MS = 20000;
 const YDB_HEALTHCHECK_READY_TIMEOUT_MS = 5000;
@@ -167,6 +176,21 @@ export async function withSession(fn) {
         throw err;
     }
 }
+export async function withQuerySession(fn, options) {
+    const d = getOrCreateDriver();
+    try {
+        return await d.queryClient.do({
+            fn,
+            timeout: options?.timeoutMs ?? TABLE_SESSION_TIMEOUT_MS,
+            idempotent: options?.idempotent,
+        });
+    }
+    catch (err) {
+        // Query sessions can also get stuck/busy; reuse the same driver refresh path.
+        void maybeRefreshDriverOnSessionError(err);
+        throw err;
+    }
+}
 export async function withStartupProbeSession(fn) {
     const d = getOrCreateDriver();
     try {

package/dist/ydb/helpers.d.ts

@@ -1,5 +1,3 @@
-export declare function buildVectorParam(vector: number[]): import("ydb-sdk-proto").Ydb.ITypedValue;
-export declare function buildJsonOrEmpty(payload?: Record<string, unknown>): import("ydb-sdk-proto").Ydb.ITypedValue;
 export declare function buildVectorBinaryParams(vector: number[]): {
     float: Buffer<ArrayBufferLike>;
     bit: Buffer<ArrayBufferLike>;

package/dist/ydb/helpers.js

@@ -1,11 +1,4 @@
-import { Types, TypedValues } from "./client.js";
 import { vectorToFloatBinary, vectorToBitBinary, } from "../utils/vectorBinary.js";
-export function buildVectorParam(vector) {
-    return TypedValues.list(Types.FLOAT, vector);
-}
-export function buildJsonOrEmpty(payload) {
-    return TypedValues.jsonDocument(JSON.stringify(payload ?? {}));
-}
 export function buildVectorBinaryParams(vector) {
     return {
         float: vectorToFloatBinary(vector),