@zilliz/milvus2-sdk-node 2.3.5 → 2.4.0

package/dist/milvus/types/Data.d.ts

@@ -1,8 +1,23 @@
 /// <reference types="node" />
-import { GrpcTimeOut, KeyValuePair, NumberArrayId, StringArrayId, keyValueObj, DataType, SegmentState, ImportState, ConsistencyLevelEnum, collectionNameReq, resStatusResponse } from '../';
-export type FloatVectors = number[];
-export type BinaryVectors = number[];
-export type Vectors = FloatVectors | BinaryVectors;
+import { GrpcTimeOut, KeyValuePair, NumberArrayId, StringArrayId, keyValueObj, DataType, SegmentState, ImportState, ConsistencyLevelEnum, collectionNameReq, resStatusResponse, RANKER_TYPE } from '../';
+export type FloatVector = number[];
+export type Float16Vector = number[] | Uint8Array;
+export type BFloat16Vector = number[] | Uint8Array;
+export type BinaryVector = number[];
+export type SparseVectorArray = (number | undefined)[];
+export type SparseVectorDic = {
+    [key: string]: number;
+};
+export type SparseVectorCSR = {
+    indices: number[];
+    values: number[];
+};
+export type SparseVectorCOO = {
+    index: number;
+    value: number;
+}[];
+export type SparseFloatVector = SparseVectorArray | SparseVectorDic | SparseVectorCSR | SparseVectorCOO;
+export type VectorTypes = FloatVector | Float16Vector | BinaryVector | BFloat16Vector | SparseFloatVector;
 export type Bool = boolean;
 export type Int8 = number;
 export type Int16 = number;
@@ -15,7 +30,7 @@ export type JSON = {
     [key: string]: any;
 };
 export type Array = Int8[] | Int16[] | Int32[] | Int64[] | Float[] | Double[] | VarChar[];
-export type FieldData = Bool | Int8 | Int16 | Int32 | Int64 | Float | Double | VarChar | JSON | Array | Vectors | FloatVectors | BinaryVectors;
+export type FieldData = Bool | Int8 | Int16 | Int32 | Int64 | Float | Double | VarChar | JSON | Array | VectorTypes;
 export interface RowData {
     [x: string]: FieldData;
 }
@@ -30,22 +45,33 @@ export interface FlushReq extends GrpcTimeOut {
     collection_names: string[];
 }
 export interface CountReq extends collectionNameReq {
+    expr?: string;
 }
+export type InsertTransformers = {
+    [DataType.BFloat16Vector]?: (bf16: BFloat16Vector) => Buffer;
+    [DataType.Float16Vector]?: (f16: Float16Vector) => Buffer;
+};
 export interface InsertReq extends collectionNameReq {
     partition_name?: string;
-    fields_data?: RowData[];
     data?: RowData[];
+    fields_data?: RowData[];
     hash_keys?: Number[];
+    transformers?: InsertTransformers;
 }
 export interface DeleteEntitiesReq extends collectionNameReq {
-    expr?: string;
     filter?: string;
+    expr?: string;
     partition_name?: string;
 }
-export interface DeleteReq extends collectionNameReq {
+export interface DeleteByIdsReq extends collectionNameReq {
     ids: string[] | number[];
     partition_name?: string;
 }
+export interface DeleteByFilterReq extends collectionNameReq {
+    filter: string;
+    partition_name?: string;
+}
+export type DeleteReq = DeleteByIdsReq | DeleteByFilterReq;
 export interface CalcDistanceReq extends GrpcTimeOut {
     op_left: any;
     op_right: any;
@@ -160,39 +186,61 @@ export interface GetMetricsRequest extends GrpcTimeOut {
 }
 export interface SearchParam {
     anns_field: string;
-    topk: string;
+    topk: string | number;
     metric_type: string;
     params: string;
+    offset?: number;
     round_decimal?: number;
     ignore_growing?: boolean;
+    group_by_field?: string;
+}
+export interface SearchReq extends collectionNameReq {
+    anns_field?: string;
+    partition_names?: string[];
+    expr?: string;
+    search_params: SearchParam;
+    vectors: VectorTypes[];
+    output_fields?: string[];
+    travel_timestamp?: string;
+    vector_type: DataType.BinaryVector | DataType.FloatVector;
+    nq?: number;
+    consistency_level?: ConsistencyLevelEnum;
+    transformers?: OutputTransformers;
 }
 export interface SearchSimpleReq extends collectionNameReq {
-    vector?: number[];
-    vectors?: number[][];
-    data?: number[][] | number[];
+    partition_names?: string[];
+    anns_field?: string;
+    data?: VectorTypes[] | VectorTypes;
+    vector?: VectorTypes;
+    vectors?: VectorTypes[];
     output_fields?: string[];
     limit?: number;
     topk?: number;
     offset?: number;
     filter?: string;
     expr?: string;
-    partition_names?: string[];
     params?: keyValueObj;
     metric_type?: string;
     consistency_level?: ConsistencyLevelEnum;
     ignore_growing?: boolean;
+    group_by_field?: string;
+    round_decimal?: number;
+    transformers?: OutputTransformers;
 }
-export interface SearchReq extends collectionNameReq {
-    partition_names?: string[];
+export type HybridSearchSingleReq = Pick<SearchParam, 'anns_field' | 'ignore_growing' | 'group_by_field'> & {
+    data: VectorTypes[] | VectorTypes;
     expr?: string;
-    search_params: SearchParam;
-    vectors: number[][];
-    output_fields?: string[];
-    travel_timestamp?: string;
-    vector_type: DataType.BinaryVector | DataType.FloatVector;
-    nq?: number;
-    consistency_level?: ConsistencyLevelEnum;
-}
+    params?: keyValueObj;
+    transformers?: OutputTransformers;
+};
+export type RerankerObj = {
+    strategy: RANKER_TYPE | string;
+    params: keyValueObj;
+};
+export type HybridSearchReq = Omit<SearchSimpleReq, 'data' | 'vector' | 'vectors' | 'params' | 'anns_field'> & {
+    data: HybridSearchSingleReq[];
+    rerank?: RerankerObj;
+};
 export interface SearchRes extends resStatusResponse {
     results: {
         top_k: number;
@@ -227,16 +275,24 @@ export interface SearchRes extends resStatusResponse {
         num_queries: number;
         topks: number[];
         output_fields: string[];
+        group_by_field_value: string;
     };
 }
+export type OutputTransformers = {
+    [DataType.BFloat16Vector]?: (bf16bytes: Uint8Array) => BFloat16Vector;
+    [DataType.Float16Vector]?: (f16: Uint8Array) => Float16Vector;
+    [DataType.SparseFloatVector]?: (sparse: SparseVectorDic) => SparseFloatVector;
+};
 export interface QueryReq extends collectionNameReq {
     output_fields?: string[];
     partition_names?: string[];
+    ids?: string[] | number[];
     expr?: string;
     filter?: string;
     offset?: number;
     limit?: number;
     consistency_level?: ConsistencyLevelEnum;
+    transformers?: OutputTransformers;
 }
 export interface GetReq extends collectionNameReq {
     ids: string[] | number[];

package/dist/milvus/types/Data.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("../");
 //# sourceMappingURL=Data.js.map

package/dist/milvus/types/Data.js.map

@@ -1 +1 @@
-{"version":3,"file":"Data.js","sourceRoot":"","sources":["../../../milvus/types/Data.ts"],"names":[],"mappings":""}
+{"version":3,"file":"Data.js","sourceRoot":"","sources":["../../../milvus/types/Data.ts"],"names":[],"mappings":";;AAAA,2BAaa"}

package/dist/milvus/types/HighLevel.d.ts

@@ -1,15 +1,18 @@
-import { DataType, MetricType, CreateIndexParam, collectionNameReq } from '../';
+import { DataType, MetricType, CreateIndexParam, collectionNameReq, CreateCollectionReq, CreateIndexSimpleReq } from '../';
 export interface CreateColReq extends collectionNameReq {
     dimension: number;
     primary_field_name?: string;
     id_type?: DataType.Int64 | DataType.VarChar;
     vector_field_name?: string;
     metric_type?: string | MetricType;
-    timeout?: number;
     enable_dynamic_field?: boolean;
     enableDynamicField?: boolean;
     description?: string;
     auto_id?: boolean;
-    timeouts?: number;
+    consistency_level?: 'Strong' | 'Session' | 'Bounded' | 'Eventually' | 'Customized';
     index_params?: CreateIndexParam;
+    timeout?: number;
 }
+export type CreateColWithSchemaAndIndexParamsReq = CreateCollectionReq & {
+    index_params: Omit<CreateIndexSimpleReq, 'collection_name'>[] | Omit<CreateIndexSimpleReq, 'collection_name'>;
+};

package/dist/milvus/types/Http.d.ts

@@ -1,4 +1,4 @@
-import { FloatVectors } from '..';
+import { FloatVector } from '..';
 type Fetch = (input: any, init?: any) => Promise<any>;
 export type Constructor<T = {}> = new (...args: any[]) => T;
 export type FetchOptions = {
@@ -7,12 +7,12 @@ export type FetchOptions = {
 };
 type HttpClientConfigBase = {
     database?: string;
-    version?: string;
     token?: string;
     username?: string;
     password?: string;
     timeout?: number;
     fetch?: Fetch;
+    acceptInt64?: boolean;
 };
 type HttpClientConfigAddress = HttpClientConfigBase & {
     endpoint: string;
@@ -32,12 +32,52 @@ export interface HttpBaseResponse<T = {}> {
     data: T;
     message?: string;
 }
+type CollectionIndexParam = {
+    metricType: string;
+    fieldName: string;
+    indexName: string;
+    params?: {
+        index_type: string;
+        nlist?: number;
+        M?: string;
+        efConstruction?: string;
+    };
+};
+type CollectionCreateParams = {
+    max_length?: number;
+    enableDynamicField?: boolean;
+    shardsNum?: number;
+    consistencyLevel?: string;
+    partitionsNum?: number;
+    ttlSeconds?: number;
+};
+type CollectionCreateField = {
+    fieldName: string;
+    dataType: string;
+    elementDataType?: string;
+    isPrimary?: boolean;
+    isPartitionKey?: boolean;
+    elementTypeParams?: {
+        max_length?: number;
+        dim?: number;
+        max_capacity?: number;
+    };
+};
+type CollectionCreateSchema = {
+    autoID?: boolean;
+    enabledDynamicField?: boolean;
+    fields: CollectionCreateField[];
+};
 export interface HttpCollectionCreateReq extends HttpBaseReq {
-    dimension: number;
+    dimension?: number;
     metricType?: string;
-    primaryField?: string;
-    vectorField?: string;
-    description?: string;
+    idType?: string;
+    autoID?: boolean;
+    primaryFieldName?: string;
+    vectorFieldName?: string;
+    schema?: CollectionCreateSchema;
+    indexParams?: CollectionIndexParam[];
+    params?: CollectionCreateParams;
 }
 export interface HttpCollectionListReq extends Omit<HttpBaseReq, 'collectionName'> {
 }
@@ -59,11 +99,31 @@ export interface HttpCollectionDescribeResponse extends HttpBaseResponse<{
     indexes: Index[];
     load: string;
     shardsNum: number;
-    enableDynamic: boolean;
+    enableDynamicField: boolean;
 }> {
 }
 export interface HttpCollectionListResponse extends HttpBaseResponse<string[]> {
 }
+export interface HttpCollectionHasResponse extends HttpBaseResponse<{
+    has: boolean;
+}> {
+}
+export interface HttpCollectionRenameReq extends HttpBaseReq {
+    newCollectionName: string;
+    newDbName?: string;
+}
+export interface HttpCollectionStatisticsResponse extends HttpBaseResponse<{
+    rowCount: number;
+}> {
+}
+export interface HttpCollectionLoadStateReq extends HttpBaseReq {
+    partitionNames?: string;
+}
+export interface HttpCollectionLoadStateResponse extends HttpBaseResponse<{
+    loadProgress: number;
+    loadState: string;
+}> {
+}
 export interface HttpVectorInsertReq extends HttpBaseReq {
     data: Record<string, any>[];
 }
@@ -72,11 +132,18 @@ export interface HttpVectorInsertResponse extends HttpBaseResponse<{
     insertIds: number | string[];
 }> {
 }
+export interface HttpVectorUpsertResponse extends HttpBaseResponse<{
+    upsertCount: number;
+    upsertIds: number | string[];
+}> {
+}
 export interface HttpVectorGetReq extends HttpBaseReq {
     id: number | number[] | string | string[];
     outputFields: string[];
 }
-export interface HttpVectorDeleteReq extends Omit<HttpVectorGetReq, 'outputFields'> {
+export interface HttpVectorDeleteReq extends HttpBaseReq {
+    filter: string;
+    partitionName?: string;
 }
 export interface HttpVectorQueryReq extends HttpBaseReq {
     outputFields: string[];
@@ -89,7 +156,7 @@ type QueryResult = Record<string, any>[];
 export interface HttpVectorQueryResponse extends HttpBaseResponse<QueryResult> {
 }
 export interface HttpVectorSearchReq extends Omit<HttpVectorQueryReq, 'filter'> {
-    vector: FloatVectors;
+    data: FloatVector[];
     filter?: string;
 }
 export interface HttpVectorSearchResponse extends HttpVectorQueryResponse {
@@ -97,4 +164,119 @@ export interface HttpVectorSearchResponse extends HttpVectorQueryResponse {
         distance: number | string;
     };
 }
+export interface HttpPartitionBaseReq extends HttpBaseReq {
+    partitionName: string;
+}
+export interface HttpPartitionListReq extends HttpBaseReq {
+    partitionNames: string[];
+}
+export interface HttpPartitionHasResponse extends HttpBaseResponse<{
+    has: boolean;
+}> {
+}
+export interface HttpPartitionStatisticsResponse extends HttpBaseResponse<{
+    rowCount: number;
+}> {
+}
+export interface HttpUserBaseReq {
+    userName: string;
+}
+export interface HttpUserCreateReq extends HttpUserBaseReq {
+    password: string;
+}
+export interface HttpUserUpdatePasswordReq extends HttpUserCreateReq {
+    newPassword: string;
+}
+export interface HttpUserRoleReq extends HttpUserBaseReq {
+    roleName: string;
+}
+export interface HttpRoleBaseReq {
+    roleName: string;
+}
+export interface HttpRolePrivilegeReq extends HttpRoleBaseReq {
+    objectType: string;
+    objectName: string;
+    privilege: string;
+}
+export interface HttpRoleDescribeResponse extends HttpBaseResponse<HttpRolePrivilegeReq[]> {
+}
+export interface HttpIndexCreateReq extends HttpBaseReq {
+    indexParams: CollectionIndexParam[];
+}
+export interface HttpIndexBaseReq extends HttpBaseReq {
+    indexName: string;
+}
+type IndexDescribeType = {
+    failReason: string;
+    fieldName: string;
+    indexName: string;
+    indexState: string;
+    indexType: string;
+    indexedRows: number;
+    metricType: string;
+    pendingRows: number;
+    totalRows: number;
+};
+export interface HttpIndexDescribeResponse extends HttpBaseResponse<IndexDescribeType[]> {
+}
+export type HttpAliasBaseReq = Pick<HttpBaseReq, 'dbName'>;
+export interface HttpAliasCreateReq extends HttpBaseReq {
+    aliasName: string;
+}
+export type HttpAliasAlterReq = HttpAliasCreateReq;
+export interface HttpAliasDescribeReq extends HttpAliasBaseReq {
+    aliasName: string;
+}
+export interface HttpAliasDescribeResponse extends HttpBaseResponse<{
+    aliasName: string;
+} & Required<HttpBaseReq>> {
+}
+export interface HttpAliasDropReq extends Partial<HttpBaseReq> {
+    aliasName: string;
+}
+type ImportJobType = {
+    collectionName: string;
+    jobId: string;
+    progress: number;
+    state: string;
+};
+type ImportJobDetailType = {
+    completeTime: string;
+    fileName: string;
+    fileSize: number;
+    importedRows: number;
+    progress: number;
+    state: string;
+    totalRows: number;
+};
+export interface HttpImportListResponse extends HttpBaseResponse<{
+    records: ImportJobType[];
+}> {
+}
+export interface HttpImportCreateReq extends HttpBaseReq {
+    files: string[][];
+    options?: {
+        timeout: string;
+    };
+}
+export interface HttpImportCreateResponse extends HttpBaseResponse<{
+    jobId: string;
+}> {
+}
+export interface HttpImportProgressReq extends Pick<HttpBaseReq, 'dbName'> {
+    jobId: string;
+}
+export interface HttpImportProgressResponse extends HttpBaseResponse<{
+    jobId: string;
+    progress: number;
+    state: string;
+    totalRows?: number;
+    importedRows?: number;
+    fileSize?: number;
+    completeTime?: string;
+    collectionName?: string;
+    details?: ImportJobDetailType[];
+    reason?: string;
+}> {
+}
 export {};

package/dist/milvus/types/MilvusIndex.d.ts

@@ -10,9 +10,11 @@ export interface CreateIndexReq extends collectionNameReq {
     index_name?: string;
     extra_params?: CreateIndexParam;
 }
+export type CreateIndexRequest = CreateIndexReq | CreateIndexSimpleReq;
+export type CreateIndexesReq = CreateIndexRequest[] | CreateIndexRequest;
 export interface CreateIndexSimpleReq extends collectionNameReq {
     field_name: string;
-    index_type?: string;
+    index_type: string;
     metric_type?: string;
     index_name?: string;
     params?: keyValueObj;
@@ -21,10 +23,15 @@ export interface DescribeIndexReq extends collectionNameReq {
     field_name?: string;
     index_name?: string;
 }
-export interface GetIndexStateReq extends DescribeIndexReq {
+export interface FieldNameReq extends collectionNameReq {
+    field_name: string;
 }
-export interface GetIndexBuildProgressReq extends DescribeIndexReq {
+export interface IndexNameReq extends collectionNameReq {
+    index_name: string;
 }
+export interface GetIndexStateReq extends DescribeIndexReq {
+}
+export type GetIndexBuildProgressReq = FieldNameReq | IndexNameReq;
 export interface DropIndexReq extends DescribeIndexReq {
 }
 export interface IndexDescription {
@@ -41,6 +48,9 @@ export interface IndexDescription {
 export interface DescribeIndexResponse extends resStatusResponse {
     index_descriptions: IndexDescription[];
 }
+export interface ListIndexResponse extends resStatusResponse {
+    indexes: string[];
+}
 export interface GetIndexStateResponse extends resStatusResponse {
     state: IndexState;
 }
@@ -48,3 +58,7 @@ export interface GetIndexBuildProgressResponse extends resStatusResponse {
     indexed_rows: number;
     total_rows: number;
 }
+export interface AlterIndexReq extends collectionNameReq {
+    index_name: string;
+    params: Record<string, number | string | boolean>;
+}

package/dist/milvus/utils/Bytes.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { Root } from 'protobufjs';
+import { FloatVector, BinaryVector, SparseFloatVector, DataType, VectorTypes, Float16Vector, BFloat16Vector } from '..';
+/**
+ * Converts a float vector into bytes format.
+ *
+ * @param {FloatVector} array - The float vector to convert.
+ * @returns {Buffer} Bytes representing the float vector.
+ */
+export declare const f32ArrayToF32Bytes: (array: FloatVector) => Buffer;
+/**
+ * Converts a binary vector into bytes format.
+ *
+ * @param {BinaryVector} array - The binary vector to convert.
+ * @returns {Buffer} Bytes representing the binary vector.
+ */
+export declare const f32ArrayToBinaryBytes: (array: BinaryVector) => Buffer;
+/**
+ * Converts a float16 vector into bytes format.
+ *
+ * @param {Float16Vector} array - The float16 vector(f32 format) to convert.
+ * @returns {Buffer} Bytes representing the float16 vector.
+ */
+export declare const f32ArrayToF16Bytes: (array: Float16Vector) => Buffer;
+/**
+ * Convert float16 bytes to float32 array.
+ * @param {Uint8Array} f16Bytes - The float16 bytes to convert.
+ * @returns {Array} The float32 array.
+ */
+export declare const f16BytesToF32Array: (f16Bytes: Uint8Array) => number[];
+/**
+ *  Convert float32 array to BFloat16 bytes, not a real conversion, just take the last 2 bytes of float32.
+ * @param {BFloat16Vector} array - The float32 array to convert.
+ * @returns {Buffer} The BFloat16 bytes.
+ */
+export declare const f32ArrayToBf16Bytes: (array: BFloat16Vector) => Buffer;
+/**
+ * Convert BFloat16 bytes to Float32 array.
+ * @param {Uint8Array} bf16Bytes - The BFloat16 bytes to convert.
+ * @returns {Array} The Float32 array.
+ */
+export declare const bf16BytesToF32Array: (bf16Bytes: Uint8Array) => number[];
+/**
+ * Get SparseVector type.
+ * @param {SparseFloatVector} vector - The sparse float vector to convert.
+ *
+ * @returns string, 'array' | 'coo' | 'csr' | 'dict'
+ */
+export declare const getSparseFloatVectorType: (vector: SparseFloatVector) => 'array' | 'coo' | 'csr' | 'dict' | 'unknown';
+/**
+ * Converts a sparse float vector into bytes format.
+ *
+ * @param {SparseFloatVector} data - The sparse float vector to convert, support 'array' | 'coo' | 'csr' | 'dict'.
+ *
+ * @returns {Uint8Array} Bytes representing the sparse float vector.
+ * @throws {Error} If the length of indices and values is not the same, or if the index is not within the valid range, or if the value is NaN.
+ */
+export declare const sparseToBytes: (data: SparseFloatVector) => Uint8Array;
+/**
+ * Converts an array of sparse float vectors into an array of bytes format.
+ *
+ * @param {SparseFloatVector[]} data - The array of sparse float vectors to convert.
+ *
+ * @returns {Uint8Array[]} An array of bytes representing the sparse float vectors.
+ */
+export declare const sparseRowsToBytes: (data: SparseFloatVector[]) => Uint8Array[];
+/**
+ * Parses the provided buffer data into a sparse row representation.
+ *
+ * @param {Buffer} bufferData - The buffer data to parse.
+ *
+ * @returns {SparseFloatVector} The parsed sparse float vectors.
+ */
+export declare const bytesToSparseRow: (bufferData: Buffer) => SparseFloatVector;
+/**
+ * This function builds a placeholder group in bytes format for Milvus.
+ *
+ * @param {Root} milvusProto - The root object of the Milvus protocol.
+ * @param {VectorTypes[]} vectors - An array of search vectors.
+ * @param {DataType} vectorDataType - The data type of the vectors.
+ *
+ * @returns {Uint8Array} The placeholder group in bytes format.
+ */
+export declare const buildPlaceholderGroupBytes: (milvusProto: Root, vectors: VectorTypes[], vectorDataType: DataType) => Uint8Array;