@relevanceai/sdk 1.98.0 → 1.100.0

package/dist-cjs/generated/DiscoveryApi.js

@@ -894,6 +894,14 @@ class DiscoveryApiClient extends BaseClient_1._GenericClient {
             options
         });
     }
+    async AppendTags(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'post',
+            path: '/datasets/{dataset_id}/tags/append',
+            options
+        });
+    }
     async DeleteTags(input, options) {
         return this.SendRequest({
             input,

package/dist-es/generated/DiscoveryApi.js

@@ -1398,6 +1398,18 @@ var DiscoveryApiClient = /** @class */ (function (_super) {
             });
         });
     };
+    DiscoveryApiClient.prototype.AppendTags = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'post',
+                        path: '/datasets/{dataset_id}/tags/append',
+                        options: options
+                    })];
+            });
+        });
+    };
     DiscoveryApiClient.prototype.DeleteTags = function (input, options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {

package/dist-types/generated/DiscoveryApi.d.ts

@@ -222,6 +222,8 @@ export declare type BulkUpdateInput = operations['BulkUpdate']['requestBody']['c
 export declare type BulkUpdateOutput = operations['BulkUpdate']['responses']['200']['content']['application/json'];
 export declare type UpdateWhereInput = operations['UpdateWhere']['requestBody']['content']['application/json'];
 export declare type UpdateWhereOutput = operations['UpdateWhere']['responses']['200']['content']['application/json'];
+export declare type AppendTagsInput = operations['AppendTags']['requestBody']['content']['application/json'];
+export declare type AppendTagsOutput = operations['AppendTags']['responses']['200']['content']['application/json'];
 export declare type DeleteTagsInput = operations['DeleteTags']['requestBody']['content']['application/json'];
 export declare type DeleteTagsOutput = operations['DeleteTags']['responses']['200']['content']['application/json'];
 export declare type MergeTagsInput = operations['MergeTags']['requestBody']['content']['application/json'];
@@ -397,6 +399,7 @@ export declare class DiscoveryApiClient extends _GenericClient {
     DeleteDocumentFields(input: CommandInput<DeleteDocumentFieldsInput>, options?: _GenericMethodOptions): Promise<CommandOutput<DeleteDocumentFieldsOutput>>;
     BulkUpdate(input: CommandInput<BulkUpdateInput>, options?: _GenericMethodOptions): Promise<CommandOutput<BulkUpdateOutput>>;
     UpdateWhere(input: CommandInput<UpdateWhereInput>, options?: _GenericMethodOptions): Promise<CommandOutput<UpdateWhereOutput>>;
+    AppendTags(input: CommandInput<AppendTagsInput>, options?: _GenericMethodOptions): Promise<CommandOutput<AppendTagsOutput>>;
     DeleteTags(input: CommandInput<DeleteTagsInput>, options?: _GenericMethodOptions): Promise<CommandOutput<DeleteTagsOutput>>;
     MergeTags(input: CommandInput<MergeTagsInput>, options?: _GenericMethodOptions): Promise<CommandOutput<MergeTagsOutput>>;
     ListFacets(input: CommandInput<ListFacetsInput>, options?: _GenericMethodOptions): Promise<CommandOutput<ListFacetsOutput>>;

package/dist-types/generated/_DiscoveryApiSchemaTypes.d.ts

@@ -1988,6 +1988,26 @@ export interface paths {
          */
         post: operations["UpdateWhere"];
     };
+    "/datasets/{dataset_id}/tags/append": {
+        /**
+         * Append tags to tag field.
+         *
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "datasets:write"
+         *     ],
+         *     "datasets": [
+         *       {
+         *         "params": "dataset_id"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        post: operations["AppendTags"];
+    };
     "/datasets/{dataset_id}/tags/delete": {
         /**
          * Delete tags from tag field by tag value. tag field can be in format ["cat"], or [{"label":"cat"}]
@@ -6940,7 +6960,46 @@ export interface components {
             send_email?: boolean;
             worker_number?: number;
         };
-        UpsertWorkflowStatusOutput: unknown;
+        UpsertWorkflowStatusOutput: {
+            creation_time?: string;
+            completion_time?: string;
+            notebook_path?: string;
+            instance_type?: string;
+            dataset_id?: string;
+            params?: {
+                [key: string]: unknown;
+            };
+            _id?: string;
+            workflow_id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /** @description Status of the workflow. Used for knowing when to send an email notification. */
+            status?: "complete" | "inprogress" | "failed";
+            job_status?: "InProgress" | "Completed" | "Failed";
+            worker_status?: {
+                [key: string]: {
+                    status?: "complete" | "inprogress" | "failed";
+                    completion_time?: string;
+                    creation_time?: string;
+                };
+            };
+            n_workers?: number;
+            steps?: {
+                [key: string]: {
+                    worker_progress?: {
+                        [key: string]: {
+                            n_processed?: number;
+                            n_total?: number;
+                        };
+                    };
+                    n_processed?: number;
+                    n_total?: number;
+                };
+            };
+        } & {
+            [key: string]: unknown;
+        };
         ListWorkflowTypesInput: unknown;
         ListWorkflowTypesOutput: {
             results: ({
@@ -7904,128 +7963,885 @@ export interface components {
                     /** @description The alias of the clustering. */
                     alias?: string;
                 };
-            }[];
-            /** @description A list of jobs to run once all documents are processed. */
-            jobs_to_trigger?: {
-                /** @description Specify this to run an encoding job after documents are processed. Supports chunk field encoding, encoding many fields, and storing results in a new field specified by alias. */
-                encode?: {
-                    /** @description Chunk field to encode. Will produce a field with _chunkvector_ suffix. */
-                    chunk_field?: string;
-                    /** @description Regular fields to encode. Will produce a field with _vector suffix. */
-                    fields?: string[];
-                    /** @description If provided, this string will be added to the output field name. */
-                    alias?: string;
-                    /** @description Model name to use for encoding. */
-                    model_name?: string;
+            }[];
+            /** @description A list of jobs to run once all documents are processed. */
+            jobs_to_trigger?: {
+                /** @description Specify this to run an encoding job after documents are processed. Supports chunk field encoding, encoding many fields, and storing results in a new field specified by alias. */
+                encode?: {
+                    /** @description Chunk field to encode. Will produce a field with _chunkvector_ suffix. */
+                    chunk_field?: string;
+                    /** @description Regular fields to encode. Will produce a field with _vector suffix. */
+                    fields?: string[];
+                    /** @description If provided, this string will be added to the output field name. */
+                    alias?: string;
+                    /** @description Model name to use for encoding. */
+                    model_name?: string;
+                };
+            }[];
+        };
+        UpdateOutput: {
+            /** @description Completion status. */
+            status: string;
+            /** @description Response message for completion state. */
+            message: string;
+        };
+        DeleteDocumentFieldsInput: {
+            /** @description _id of document to delete fields of. */
+            id: string;
+            /** @description List of fields to delete in a document */
+            fields: string[];
+        };
+        DeleteDocumentFieldsOutput: unknown;
+        BulkUpdateInput: {
+            /** @description List of updates to apply to documents. Each update item must contain an _id. */
+            updates: ({
+                _id?: unknown;
+            } & {
+                [key: string]: unknown;
+            })[];
+            /** @description Return immediately after storing data in a spot where it can be ingested in the background. Best for large datasets. */
+            ingest_in_background?: boolean;
+            /**
+             * @description Whether to include insert date as a field 'insert_date_'.
+             * @default true
+             */
+            insert_date?: boolean;
+            /**
+             * @description Whether to transform fields containing dates to a valid Relevance date format.
+             * @default true
+             */
+            transform_date_format?: boolean;
+            /**
+             * @description Whether to overwrite document if it exists.
+             * @default true
+             */
+            overwrite?: boolean;
+            /**
+             * @description Whether the api should check the documents for vector datatype to update the schema.
+             * @default true
+             */
+            update_schema?: boolean;
+            /**
+             * @description Whether to return before all documents have finished updating.
+             * @default true
+             */
+            wait_for_update?: boolean;
+            encoders?: {
+                /** @description The model url to use */
+                model_url?: string;
+                /** @description The model name to use. */
+                model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "clip-vit-l-14-image" | "clip-vit-l-14-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
+                /** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
+                body?: string;
+                /** @description The document field to encode. */
+                field: string;
+                /** @description Add 'alias' to a created vector field name. Output format is {field}_{alias}_vector_. */
+                alias?: string;
+            }[];
+            /** @description Before insertion, fields of documents will be transformed according to this array of rules. If transformation fails, the output field will not be generated. */
+            field_transformers?: {
+                /** @description Field to transform. to transform a nested field, use a.b */
+                field: string;
+                /** @description If specified, place result in this field. To place in a nested field, use format a.b */
+                output_field?: string;
+                /** @description Whether to strip html tags from field. */
+                remove_html?: boolean;
+                /** @description Whether transform a text field into an array of text by splitting sentences. */
+                split_sentences?: boolean;
+                /** @description If specified, documents with the vector fields will be clustered according to the clustering alias */
+                assign_to_cluster?: {
+                    /** @description The alias of the clustering. */
+                    alias?: string;
+                };
+            }[];
+            /** @description A list of jobs to run once all documents are processed. */
+            jobs_to_trigger?: {
+                /** @description Specify this to run an encoding job after documents are processed. Supports chunk field encoding, encoding many fields, and storing results in a new field specified by alias. */
+                encode?: {
+                    /** @description Chunk field to encode. Will produce a field with _chunkvector_ suffix. */
+                    chunk_field?: string;
+                    /** @description Regular fields to encode. Will produce a field with _vector suffix. */
+                    fields?: string[];
+                    /** @description If provided, this string will be added to the output field name. */
+                    alias?: string;
+                    /** @description Model name to use for encoding. */
+                    model_name?: string;
+                };
+            }[];
+        };
+        BulkUpdateOutput: {
+            /** @description Number of successfully processed documents. */
+            inserted: number;
+            /** @description Information about documents that were not processed successfully. */
+            failed_documents: {
+                /** @description _id field of unprocessed document. */
+                _id?: unknown;
+                error?: {
+                    /** @description http status code of individual document insertion operation. */
+                    status?: number;
+                    /** @description body response of individual document insertion operation. */
+                    body?: string;
+                };
+            }[];
+        };
+        UpdateWhereInput: {
+            filters?: (Partial<{
+                /** @description Match where document[field] is in value list. */
+                match?: {
+                    /** @description If matching on text, match even if there are extra words / case insensitivity */
+                    fuzzy?: boolean;
+                    /** @description Field to match on. */
+                    field?: string;
+                    /** @description Can be either a single item or a list of items to match on. */
+                    value: string | boolean | number | unknown[];
+                };
+                /** @description Match where document._id is in value list. */
+                matchIds?: {
+                    /** @description Can be either a single item or a list of items to match on. */
+                    value: string | boolean | number | unknown[];
+                };
+                /** @description Match documents where greaterThan < document[field] < lessThan. Supports numbers and date strings. */
+                range?: {
+                    /** @description Field to match on. */
+                    field?: string;
+                    greaterThan?: unknown;
+                    lessThan?: unknown;
+                    greaterThanOrEqualTo?: unknown;
+                    lessThanOrEqualTo?: unknown;
+                };
+                /**
+                 * @description
+                 * Match documents where the field either contains the value as a substring, or matches a provided matching pattern.
+                 *
+                 * Possible matching patterns:
+                 *
+                 * * - documents where the field has any value
+                 * ? - documents where a single character from the field matches the provided values
+                 *
+                 * Example:
+                 *
+                 * {
+                 *   wildcard: {
+                 *      field: "title",
+                 *      value: [ "Avenger*" ]
+                 *   }
+                 * }
+                 */
+                wildcard?: {
+                    /** @description Field to match on. */
+                    field?: string;
+                    /** @description single string or array of valid wildcard strings to match on, for example ['tele*'] */
+                    value: string | string[];
+                };
+                /** @description hybrid search query that must reach a certain value to filter */
+                search?: {
+                    /**
+                     * @description Search for documents that contain this query string in your dataset. Use fieldsToSearch parameter to restrict which fields are searched.
+                     *
+                     *     "tele" matches "Television", "This television is an excellent product…"
+                     *
+                     *     Example: "tele"
+                     */
+                    query?: string;
+                    /** @description Configuration for traditional search query. */
+                    queryConfig?: {
+                        /**
+                         * @description Increases or decreases the impact of all traditional search matching when calculating a documents _relevance.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /**
+                         * @description Increases or decreases the impact of sentence matching when calculating a documents _relevance.
+                         *         For example, with query "A fox jumped", with high sentence weight, 'A fox jumped over the' would match before 'jumped a fox over fox'
+                         * @default 1
+                         */
+                        sentenceWeight?: number;
+                        /**
+                         * @description Increases or decreases the impact of fuzzy matching when calculating a documents _relevance.
+                         *         For example, with query "rain", with 0 fuzzy weight, 'brain' would not match.
+                         * @default 1
+                         */
+                        fuzzyWeight?: number;
+                    };
+                    /**
+                     * @description Prioritise the result list of documents based on semantic similarity to "query" provided here.
+                     *
+                     *     For example if field "animaltype_vector_" contains encoded vector values for "cat", lion, "dog","bird", and "query" is set to "kitten", documents with "cat", "lion" will be returned first in the results list.
+                     *
+                     *     It can be an object or a list of objects.
+                     *
+                     *
+                     *
+                     *     Example payloads:
+                     *
+                     *     {"field":"animaltype_vector_","query":"kitten"}
+                     *
+                     *     [
+                     *
+                     *     {"field":"animaltype_vector_","query":"kitten","weight":1","model":"text"}, {"field":"animaltype_vector_","query":"https://www.dogimage.com/dogimage.png","model":"image","weight":2}
+                     *
+                     *     ]
+                     */
+                    vectorSearchQuery?: {
+                        /** @description Vector name to search on. For example, title_vector_ */
+                        field: string;
+                        /** @description Query to transform to a vector and then search with. Default to query in the root body if not provided. */
+                        query?: string;
+                        /**
+                         * @description Model name to generate the vector with.
+                         * @default text
+                         */
+                        model?: string;
+                        /** @description Model url to use for encoding. If model and model_url are both set, model_url will override it. */
+                        model_url?: string;
+                        /**
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Instead of generating a vector by vectorising the query, use the vector provided here for vector search. */
+                        vector?: number[];
+                        chunkConfig?: {
+                            chunkField: string;
+                            page?: number;
+                            pageSize?: number;
+                        };
+                    } | {
+                        /** @description Vector name to search on. For example, title_vector_ */
+                        field: string;
+                        /** @description Query to transform to a vector and then search with. Default to query in the root body if not provided. */
+                        query?: string;
+                        /**
+                         * @description Model name to generate the vector with.
+                         * @default text
+                         */
+                        model?: string;
+                        /** @description Model url to use for encoding. If model and model_url are both set, model_url will override it. */
+                        model_url?: string;
+                        /**
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Instead of generating a vector by vectorising the query, use the vector provided here for vector search. */
+                        vector?: number[];
+                        chunkConfig?: {
+                            chunkField: string;
+                            page?: number;
+                            pageSize?: number;
+                        };
+                    }[];
+                    realtimeClustering?: {
+                        /** @default 4 */
+                        nClusters?: number;
+                        /** @default kmeans-realtime-4 */
+                        alias?: string;
+                        vectorField: string;
+                        /** @default _cluster_.{vector_field}.{alias} */
+                        outputField?: string;
+                    };
+                    /**
+                     * @description A list of fields to search using the "query" parameter.
+                     *
+                     *     Each item can be field name as a string, or an object with 'field' as field name and optional parameters such as field weight.
+                     *
+                     *     Default behaviour is to search all fields.
+                     *
+                     *     Example: ["name",{"field":"favourite_color","weight":0.2}]
+                     */
+                    fieldsToSearch?: (string | {
+                        /** @description Field name to search. */
+                        field?: string;
+                        /**
+                         * @description Multiply the relevance contribution of a specific field when using traditional search.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Enabled text search on chunk fields. Scoring will take the max similarity of any subitem within the chunk. */
+                        chunkField?: string;
+                    })[];
+                    /**
+                     * @description Only return documents with a _relevance above this threshold.
+                     *
+                     *     Example: 0.3
+                     */
+                    minimumRelevance: number;
+                };
+                /** @description Match documents where field specified by 'field' exists in the document. for nested fields, use syntax: a.b.c */
+                fieldExists?: {
+                    /** @description Field that must exist. */
+                    field?: string;
+                };
+                /** @description Match documents where doc[field] % module == value */
+                matchModulo?: {
+                    /** @default _id */
+                    field?: string;
+                    modulo: number;
+                    value: number;
+                };
+                /** @description Filter down to one document for each value of selected field. */
+                dedupeByValue?: {
+                    /** @description Field to filter on. */
+                    field: string;
+                };
+                /** @description Match documents where document[a] <=/>=/</>/==/!=/stringEquals document[b]. Use stringEquals to compare strings. */
+                selfreference?: {
+                    /** @description First field in comparison. */
+                    a: string;
+                    /** @description Second field in comparison. */
+                    b: string;
+                    /** @description Operator used to compare a and b. */
+                    operation: "<=" | ">=" | "<" | ">" | "==" | "!=" | "stringEquals";
+                };
+                /** @description Match documents where greaterThan < wordCount(document[field]) < lessThan. */
+                wordCount?: {
+                    /** @description Field to match on. */
+                    field: string;
+                    /** @description Minimum word count. */
+                    greaterThan?: number;
+                    /** @description Maximum word count. */
+                    lessThan?: number;
+                };
+                /** @description Match documents where greaterThan < characterCount(document[field]) < lessThan. */
+                characterCount?: {
+                    /** @description Field to match on. */
+                    field: string;
+                    /** @description Minimum character count. */
+                    greaterThan?: number;
+                    /** @description Maximum character count. */
+                    lessThan?: number;
+                };
+                /** @description Used to perform a logical OR of filters. each element of the OR list can itself be a list  to perform a nested AND. {or:[[A,B],C]} is equivalent to (A AND B) OR C */
+                or?: (components["schemas"]["simpleSearchAndFlatFilterItem"][] | components["schemas"]["simpleSearchAndFlatFilterItem"])[];
+                /** @description Used to perform NOT filter. Can be a single filter or a list of filters to perform a !(AND). {not:[A,B]} is equivalent to !(A AND B) */
+                not?: components["schemas"]["simpleSearchAndFlatFilterItem"][] | components["schemas"]["simpleSearchAndFlatFilterItem"];
+                /** @description Filter based on data within a _chunk_ field. */
+                chunk?: {
+                    /** @description The path of the chunk field to filter on. For example: description_sentences_chunk_ */
+                    path: string;
+                    filters: components["schemas"]["simpleSearchAndFlatFilterItem"][];
+                };
+            }> & Partial<{
+                strict?: "must" | "should" | "must_or";
+                condition?: string;
+                field?: string;
+                filter_type?: "text_match" | "word_match" | "term" | "terms" | "text" | "texts" | "match" | "contains" | "substring" | "class" | "category" | "exact_match" | "classes" | "categories" | "exists" | "traditional" | "fuzzy" | "regexp" | "ids" | "date" | "numeric" | "search" | "or" | "word_count" | "character_count" | "dedupe_by_value";
+                condition_value?: unknown;
+                fuzzy?: number;
+                join?: boolean;
+            }>)[];
+            /** @description Updates to make to the documents. It should be specified in a format of {"field_name": "value"}. e.g. {"item.status" : "Sold Out"} */
+            updates: {
+                [key: string]: unknown;
+            };
+        };
+        UpdateWhereOutput: {
+            /** @description Completion status. */
+            status: string;
+            /** @description Response message for completion state. */
+            message: string;
+        };
+        AppendTagsInput: {
+            filters?: (Partial<{
+                /** @description Match where document[field] is in value list. */
+                match?: {
+                    /** @description If matching on text, match even if there are extra words / case insensitivity */
+                    fuzzy?: boolean;
+                    /** @description Field to match on. */
+                    field?: string;
+                    /** @description Can be either a single item or a list of items to match on. */
+                    value: string | boolean | number | unknown[];
+                };
+                /** @description Match where document._id is in value list. */
+                matchIds?: {
+                    /** @description Can be either a single item or a list of items to match on. */
+                    value: string | boolean | number | unknown[];
+                };
+                /** @description Match documents where greaterThan < document[field] < lessThan. Supports numbers and date strings. */
+                range?: {
+                    /** @description Field to match on. */
+                    field?: string;
+                    greaterThan?: unknown;
+                    lessThan?: unknown;
+                    greaterThanOrEqualTo?: unknown;
+                    lessThanOrEqualTo?: unknown;
+                };
+                /**
+                 * @description
+                 * Match documents where the field either contains the value as a substring, or matches a provided matching pattern.
+                 *
+                 * Possible matching patterns:
+                 *
+                 * * - documents where the field has any value
+                 * ? - documents where a single character from the field matches the provided values
+                 *
+                 * Example:
+                 *
+                 * {
+                 *   wildcard: {
+                 *      field: "title",
+                 *      value: [ "Avenger*" ]
+                 *   }
+                 * }
+                 */
+                wildcard?: {
+                    /** @description Field to match on. */
+                    field?: string;
+                    /** @description single string or array of valid wildcard strings to match on, for example ['tele*'] */
+                    value: string | string[];
+                };
+                /** @description hybrid search query that must reach a certain value to filter */
+                search?: {
+                    /**
+                     * @description Search for documents that contain this query string in your dataset. Use fieldsToSearch parameter to restrict which fields are searched.
+                     *
+                     *     "tele" matches "Television", "This television is an excellent product…"
+                     *
+                     *     Example: "tele"
+                     */
+                    query?: string;
+                    /** @description Configuration for traditional search query. */
+                    queryConfig?: {
+                        /**
+                         * @description Increases or decreases the impact of all traditional search matching when calculating a documents _relevance.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /**
+                         * @description Increases or decreases the impact of sentence matching when calculating a documents _relevance.
+                         *         For example, with query "A fox jumped", with high sentence weight, 'A fox jumped over the' would match before 'jumped a fox over fox'
+                         * @default 1
+                         */
+                        sentenceWeight?: number;
+                        /**
+                         * @description Increases or decreases the impact of fuzzy matching when calculating a documents _relevance.
+                         *         For example, with query "rain", with 0 fuzzy weight, 'brain' would not match.
+                         * @default 1
+                         */
+                        fuzzyWeight?: number;
+                    };
+                    /**
+                     * @description Prioritise the result list of documents based on semantic similarity to "query" provided here.
+                     *
+                     *     For example if field "animaltype_vector_" contains encoded vector values for "cat", lion, "dog","bird", and "query" is set to "kitten", documents with "cat", "lion" will be returned first in the results list.
+                     *
+                     *     It can be an object or a list of objects.
+                     *
+                     *
+                     *
+                     *     Example payloads:
+                     *
+                     *     {"field":"animaltype_vector_","query":"kitten"}
+                     *
+                     *     [
+                     *
+                     *     {"field":"animaltype_vector_","query":"kitten","weight":1","model":"text"}, {"field":"animaltype_vector_","query":"https://www.dogimage.com/dogimage.png","model":"image","weight":2}
+                     *
+                     *     ]
+                     */
+                    vectorSearchQuery?: {
+                        /** @description Vector name to search on. For example, title_vector_ */
+                        field: string;
+                        /** @description Query to transform to a vector and then search with. Default to query in the root body if not provided. */
+                        query?: string;
+                        /**
+                         * @description Model name to generate the vector with.
+                         * @default text
+                         */
+                        model?: string;
+                        /** @description Model url to use for encoding. If model and model_url are both set, model_url will override it. */
+                        model_url?: string;
+                        /**
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Instead of generating a vector by vectorising the query, use the vector provided here for vector search. */
+                        vector?: number[];
+                        chunkConfig?: {
+                            chunkField: string;
+                            page?: number;
+                            pageSize?: number;
+                        };
+                    } | {
+                        /** @description Vector name to search on. For example, title_vector_ */
+                        field: string;
+                        /** @description Query to transform to a vector and then search with. Default to query in the root body if not provided. */
+                        query?: string;
+                        /**
+                         * @description Model name to generate the vector with.
+                         * @default text
+                         */
+                        model?: string;
+                        /** @description Model url to use for encoding. If model and model_url are both set, model_url will override it. */
+                        model_url?: string;
+                        /**
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Instead of generating a vector by vectorising the query, use the vector provided here for vector search. */
+                        vector?: number[];
+                        chunkConfig?: {
+                            chunkField: string;
+                            page?: number;
+                            pageSize?: number;
+                        };
+                    }[];
+                    realtimeClustering?: {
+                        /** @default 4 */
+                        nClusters?: number;
+                        /** @default kmeans-realtime-4 */
+                        alias?: string;
+                        vectorField: string;
+                        /** @default _cluster_.{vector_field}.{alias} */
+                        outputField?: string;
+                    };
+                    /**
+                     * @description A list of fields to search using the "query" parameter.
+                     *
+                     *     Each item can be field name as a string, or an object with 'field' as field name and optional parameters such as field weight.
+                     *
+                     *     Default behaviour is to search all fields.
+                     *
+                     *     Example: ["name",{"field":"favourite_color","weight":0.2}]
+                     */
+                    fieldsToSearch?: (string | {
+                        /** @description Field name to search. */
+                        field?: string;
+                        /**
+                         * @description Multiply the relevance contribution of a specific field when using traditional search.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Enabled text search on chunk fields. Scoring will take the max similarity of any subitem within the chunk. */
+                        chunkField?: string;
+                    })[];
+                    /**
+                     * @description Only return documents with a _relevance above this threshold.
+                     *
+                     *     Example: 0.3
+                     */
+                    minimumRelevance: number;
+                };
+                /** @description Match documents where field specified by 'field' exists in the document. for nested fields, use syntax: a.b.c */
+                fieldExists?: {
+                    /** @description Field that must exist. */
+                    field?: string;
+                };
+                /** @description Match documents where doc[field] % module == value */
+                matchModulo?: {
+                    /** @default _id */
+                    field?: string;
+                    modulo: number;
+                    value: number;
+                };
+                /** @description Filter down to one document for each value of selected field. */
+                dedupeByValue?: {
+                    /** @description Field to filter on. */
+                    field: string;
+                };
+                /** @description Match documents where document[a] <=/>=/</>/==/!=/stringEquals document[b]. Use stringEquals to compare strings. */
+                selfreference?: {
+                    /** @description First field in comparison. */
+                    a: string;
+                    /** @description Second field in comparison. */
+                    b: string;
+                    /** @description Operator used to compare a and b. */
+                    operation: "<=" | ">=" | "<" | ">" | "==" | "!=" | "stringEquals";
+                };
+                /** @description Match documents where greaterThan < wordCount(document[field]) < lessThan. */
+                wordCount?: {
+                    /** @description Field to match on. */
+                    field: string;
+                    /** @description Minimum word count. */
+                    greaterThan?: number;
+                    /** @description Maximum word count. */
+                    lessThan?: number;
+                };
+                /** @description Match documents where greaterThan < characterCount(document[field]) < lessThan. */
+                characterCount?: {
+                    /** @description Field to match on. */
+                    field: string;
+                    /** @description Minimum character count. */
+                    greaterThan?: number;
+                    /** @description Maximum character count. */
+                    lessThan?: number;
+                };
+                /** @description Used to perform a logical OR of filters. each element of the OR list can itself be a list  to perform a nested AND. {or:[[A,B],C]} is equivalent to (A AND B) OR C */
+                or?: (components["schemas"]["simpleSearchAndFlatFilterItem"][] | components["schemas"]["simpleSearchAndFlatFilterItem"])[];
+                /** @description Used to perform NOT filter. Can be a single filter or a list of filters to perform a !(AND). {not:[A,B]} is equivalent to !(A AND B) */
+                not?: components["schemas"]["simpleSearchAndFlatFilterItem"][] | components["schemas"]["simpleSearchAndFlatFilterItem"];
+                /** @description Filter based on data within a _chunk_ field. */
+                chunk?: {
+                    /** @description The path of the chunk field to filter on. For example: description_sentences_chunk_ */
+                    path: string;
+                    filters: components["schemas"]["simpleSearchAndFlatFilterItem"][];
+                };
+            }> & Partial<{
+                strict?: "must" | "should" | "must_or";
+                condition?: string;
+                field?: string;
+                filter_type?: "text_match" | "word_match" | "term" | "terms" | "text" | "texts" | "match" | "contains" | "substring" | "class" | "category" | "exact_match" | "classes" | "categories" | "exists" | "traditional" | "fuzzy" | "regexp" | "ids" | "date" | "numeric" | "search" | "or" | "word_count" | "character_count" | "dedupe_by_value";
+                condition_value?: unknown;
+                fuzzy?: number;
+                join?: boolean;
+            }>)[];
+            field: string;
+            tags_to_add: string[];
+        };
+        AppendTagsOutput: unknown;
+        DeleteTagsInput: {
+            filters?: (Partial<{
+                /** @description Match where document[field] is in value list. */
+                match?: {
+                    /** @description If matching on text, match even if there are extra words / case insensitivity */
+                    fuzzy?: boolean;
+                    /** @description Field to match on. */
+                    field?: string;
+                    /** @description Can be either a single item or a list of items to match on. */
+                    value: string | boolean | number | unknown[];
+                };
+                /** @description Match where document._id is in value list. */
+                matchIds?: {
+                    /** @description Can be either a single item or a list of items to match on. */
+                    value: string | boolean | number | unknown[];
+                };
+                /** @description Match documents where greaterThan < document[field] < lessThan. Supports numbers and date strings. */
+                range?: {
+                    /** @description Field to match on. */
+                    field?: string;
+                    greaterThan?: unknown;
+                    lessThan?: unknown;
+                    greaterThanOrEqualTo?: unknown;
+                    lessThanOrEqualTo?: unknown;
+                };
+                /**
+                 * @description
+                 * Match documents where the field either contains the value as a substring, or matches a provided matching pattern.
+                 *
+                 * Possible matching patterns:
+                 *
+                 * * - documents where the field has any value
+                 * ? - documents where a single character from the field matches the provided values
+                 *
+                 * Example:
+                 *
+                 * {
+                 *   wildcard: {
+                 *      field: "title",
+                 *      value: [ "Avenger*" ]
+                 *   }
+                 * }
+                 */
+                wildcard?: {
+                    /** @description Field to match on. */
+                    field?: string;
+                    /** @description single string or array of valid wildcard strings to match on, for example ['tele*'] */
+                    value: string | string[];
+                };
+                /** @description hybrid search query that must reach a certain value to filter */
+                search?: {
+                    /**
+                     * @description Search for documents that contain this query string in your dataset. Use fieldsToSearch parameter to restrict which fields are searched.
+                     *
+                     *     "tele" matches "Television", "This television is an excellent product…"
+                     *
+                     *     Example: "tele"
+                     */
+                    query?: string;
+                    /** @description Configuration for traditional search query. */
+                    queryConfig?: {
+                        /**
+                         * @description Increases or decreases the impact of all traditional search matching when calculating a documents _relevance.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /**
+                         * @description Increases or decreases the impact of sentence matching when calculating a documents _relevance.
+                         *         For example, with query "A fox jumped", with high sentence weight, 'A fox jumped over the' would match before 'jumped a fox over fox'
+                         * @default 1
+                         */
+                        sentenceWeight?: number;
+                        /**
+                         * @description Increases or decreases the impact of fuzzy matching when calculating a documents _relevance.
+                         *         For example, with query "rain", with 0 fuzzy weight, 'brain' would not match.
+                         * @default 1
+                         */
+                        fuzzyWeight?: number;
+                    };
+                    /**
+                     * @description Prioritise the result list of documents based on semantic similarity to "query" provided here.
+                     *
+                     *     For example if field "animaltype_vector_" contains encoded vector values for "cat", lion, "dog","bird", and "query" is set to "kitten", documents with "cat", "lion" will be returned first in the results list.
+                     *
+                     *     It can be an object or a list of objects.
+                     *
+                     *
+                     *
+                     *     Example payloads:
+                     *
+                     *     {"field":"animaltype_vector_","query":"kitten"}
+                     *
+                     *     [
+                     *
+                     *     {"field":"animaltype_vector_","query":"kitten","weight":1","model":"text"}, {"field":"animaltype_vector_","query":"https://www.dogimage.com/dogimage.png","model":"image","weight":2}
+                     *
+                     *     ]
+                     */
+                    vectorSearchQuery?: {
+                        /** @description Vector name to search on. For example, title_vector_ */
+                        field: string;
+                        /** @description Query to transform to a vector and then search with. Default to query in the root body if not provided. */
+                        query?: string;
+                        /**
+                         * @description Model name to generate the vector with.
+                         * @default text
+                         */
+                        model?: string;
+                        /** @description Model url to use for encoding. If model and model_url are both set, model_url will override it. */
+                        model_url?: string;
+                        /**
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Instead of generating a vector by vectorising the query, use the vector provided here for vector search. */
+                        vector?: number[];
+                        chunkConfig?: {
+                            chunkField: string;
+                            page?: number;
+                            pageSize?: number;
+                        };
+                    } | {
+                        /** @description Vector name to search on. For example, title_vector_ */
+                        field: string;
+                        /** @description Query to transform to a vector and then search with. Default to query in the root body if not provided. */
+                        query?: string;
+                        /**
+                         * @description Model name to generate the vector with.
+                         * @default text
+                         */
+                        model?: string;
+                        /** @description Model url to use for encoding. If model and model_url are both set, model_url will override it. */
+                        model_url?: string;
+                        /**
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Instead of generating a vector by vectorising the query, use the vector provided here for vector search. */
+                        vector?: number[];
+                        chunkConfig?: {
+                            chunkField: string;
+                            page?: number;
+                            pageSize?: number;
+                        };
+                    }[];
+                    realtimeClustering?: {
+                        /** @default 4 */
+                        nClusters?: number;
+                        /** @default kmeans-realtime-4 */
+                        alias?: string;
+                        vectorField: string;
+                        /** @default _cluster_.{vector_field}.{alias} */
+                        outputField?: string;
+                    };
+                    /**
+                     * @description A list of fields to search using the "query" parameter.
+                     *
+                     *     Each item can be field name as a string, or an object with 'field' as field name and optional parameters such as field weight.
+                     *
+                     *     Default behaviour is to search all fields.
+                     *
+                     *     Example: ["name",{"field":"favourite_color","weight":0.2}]
+                     */
+                    fieldsToSearch?: (string | {
+                        /** @description Field name to search. */
+                        field?: string;
+                        /**
+                         * @description Multiply the relevance contribution of a specific field when using traditional search.
+                         * @default 1
+                         */
+                        weight?: number;
+                        /** @description Enabled text search on chunk fields. Scoring will take the max similarity of any subitem within the chunk. */
+                        chunkField?: string;
+                    })[];
+                    /**
+                     * @description Only return documents with a _relevance above this threshold.
+                     *
+                     *     Example: 0.3
+                     */
+                    minimumRelevance: number;
+                };
+                /** @description Match documents where field specified by 'field' exists in the document. for nested fields, use syntax: a.b.c */
+                fieldExists?: {
+                    /** @description Field that must exist. */
+                    field?: string;
                 };
-            }[];
-        };
-        UpdateOutput: {
-            /** @description Completion status. */
-            status: string;
-            /** @description Response message for completion state. */
-            message: string;
-        };
-        DeleteDocumentFieldsInput: {
-            /** @description _id of document to delete fields of. */
-            id: string;
-            /** @description List of fields to delete in a document */
-            fields: string[];
-        };
-        DeleteDocumentFieldsOutput: unknown;
-        BulkUpdateInput: {
-            /** @description List of updates to apply to documents. Each update item must contain an _id. */
-            updates: ({
-                _id?: unknown;
-            } & {
-                [key: string]: unknown;
-            })[];
-            /** @description Return immediately after storing data in a spot where it can be ingested in the background. Best for large datasets. */
-            ingest_in_background?: boolean;
-            /**
-             * @description Whether to include insert date as a field 'insert_date_'.
-             * @default true
-             */
-            insert_date?: boolean;
-            /**
-             * @description Whether to transform fields containing dates to a valid Relevance date format.
-             * @default true
-             */
-            transform_date_format?: boolean;
-            /**
-             * @description Whether to overwrite document if it exists.
-             * @default true
-             */
-            overwrite?: boolean;
-            /**
-             * @description Whether the api should check the documents for vector datatype to update the schema.
-             * @default true
-             */
-            update_schema?: boolean;
-            /**
-             * @description Whether to return before all documents have finished updating.
-             * @default true
-             */
-            wait_for_update?: boolean;
-            encoders?: {
-                /** @description The model url to use */
-                model_url?: string;
-                /** @description The model name to use. */
-                model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "clip-vit-l-14-image" | "clip-vit-l-14-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
-                /** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
-                body?: string;
-                /** @description The document field to encode. */
-                field: string;
-                /** @description Add 'alias' to a created vector field name. Output format is {field}_{alias}_vector_. */
-                alias?: string;
-            }[];
-            /** @description Before insertion, fields of documents will be transformed according to this array of rules. If transformation fails, the output field will not be generated. */
-            field_transformers?: {
-                /** @description Field to transform. to transform a nested field, use a.b */
-                field: string;
-                /** @description If specified, place result in this field. To place in a nested field, use format a.b */
-                output_field?: string;
-                /** @description Whether to strip html tags from field. */
-                remove_html?: boolean;
-                /** @description Whether transform a text field into an array of text by splitting sentences. */
-                split_sentences?: boolean;
-                /** @description If specified, documents with the vector fields will be clustered according to the clustering alias */
-                assign_to_cluster?: {
-                    /** @description The alias of the clustering. */
-                    alias?: string;
+                /** @description Match documents where doc[field] % module == value */
+                matchModulo?: {
+                    /** @default _id */
+                    field?: string;
+                    modulo: number;
+                    value: number;
                 };
-            }[];
-            /** @description A list of jobs to run once all documents are processed. */
-            jobs_to_trigger?: {
-                /** @description Specify this to run an encoding job after documents are processed. Supports chunk field encoding, encoding many fields, and storing results in a new field specified by alias. */
-                encode?: {
-                    /** @description Chunk field to encode. Will produce a field with _chunkvector_ suffix. */
-                    chunk_field?: string;
-                    /** @description Regular fields to encode. Will produce a field with _vector suffix. */
-                    fields?: string[];
-                    /** @description If provided, this string will be added to the output field name. */
-                    alias?: string;
-                    /** @description Model name to use for encoding. */
-                    model_name?: string;
+                /** @description Filter down to one document for each value of selected field. */
+                dedupeByValue?: {
+                    /** @description Field to filter on. */
+                    field: string;
                 };
-            }[];
-        };
-        BulkUpdateOutput: {
-            /** @description Number of successfully processed documents. */
-            inserted: number;
-            /** @description Information about documents that were not processed successfully. */
-            failed_documents: {
-                /** @description _id field of unprocessed document. */
-                _id?: unknown;
-                error?: {
-                    /** @description http status code of individual document insertion operation. */
-                    status?: number;
-                    /** @description body response of individual document insertion operation. */
-                    body?: string;
+                /** @description Match documents where document[a] <=/>=/</>/==/!=/stringEquals document[b]. Use stringEquals to compare strings. */
+                selfreference?: {
+                    /** @description First field in comparison. */
+                    a: string;
+                    /** @description Second field in comparison. */
+                    b: string;
+                    /** @description Operator used to compare a and b. */
+                    operation: "<=" | ">=" | "<" | ">" | "==" | "!=" | "stringEquals";
                 };
-            }[];
+                /** @description Match documents where greaterThan < wordCount(document[field]) < lessThan. */
+                wordCount?: {
+                    /** @description Field to match on. */
+                    field: string;
+                    /** @description Minimum word count. */
+                    greaterThan?: number;
+                    /** @description Maximum word count. */
+                    lessThan?: number;
+                };
+                /** @description Match documents where greaterThan < characterCount(document[field]) < lessThan. */
+                characterCount?: {
+                    /** @description Field to match on. */
+                    field: string;
+                    /** @description Minimum character count. */
+                    greaterThan?: number;
+                    /** @description Maximum character count. */
+                    lessThan?: number;
+                };
+                /** @description Used to perform a logical OR of filters. each element of the OR list can itself be a list  to perform a nested AND. {or:[[A,B],C]} is equivalent to (A AND B) OR C */
+                or?: (components["schemas"]["simpleSearchAndFlatFilterItem"][] | components["schemas"]["simpleSearchAndFlatFilterItem"])[];
+                /** @description Used to perform NOT filter. Can be a single filter or a list of filters to perform a !(AND). {not:[A,B]} is equivalent to !(A AND B) */
+                not?: components["schemas"]["simpleSearchAndFlatFilterItem"][] | components["schemas"]["simpleSearchAndFlatFilterItem"];
+                /** @description Filter based on data within a _chunk_ field. */
+                chunk?: {
+                    /** @description The path of the chunk field to filter on. For example: description_sentences_chunk_ */
+                    path: string;
+                    filters: components["schemas"]["simpleSearchAndFlatFilterItem"][];
+                };
+            }> & Partial<{
+                strict?: "must" | "should" | "must_or";
+                condition?: string;
+                field?: string;
+                filter_type?: "text_match" | "word_match" | "term" | "terms" | "text" | "texts" | "match" | "contains" | "substring" | "class" | "category" | "exact_match" | "classes" | "categories" | "exists" | "traditional" | "fuzzy" | "regexp" | "ids" | "date" | "numeric" | "search" | "or" | "word_count" | "character_count" | "dedupe_by_value";
+                condition_value?: unknown;
+                fuzzy?: number;
+                join?: boolean;
+            }>)[];
+            field: string;
+            tags_to_delete: string[];
         };
-        UpdateWhereInput: {
+        DeleteTagsOutput: unknown;
+        MergeTagsInput: {
             filters?: (Partial<{
                 /** @description Match where document[field] is in value list. */
                 match?: {
@@ -8271,23 +9087,6 @@ export interface components {
                 fuzzy?: number;
                 join?: boolean;
             }>)[];
-            /** @description Updates to make to the documents. It should be specified in a format of {"field_name": "value"}. e.g. {"item.status" : "Sold Out"} */
-            updates: {
-                [key: string]: unknown;
-            };
-        };
-        UpdateWhereOutput: {
-            /** @description Completion status. */
-            status: string;
-            /** @description Response message for completion state. */
-            message: string;
-        };
-        DeleteTagsInput: {
-            field: string;
-            tags_to_delete: string[];
-        };
-        DeleteTagsOutput: unknown;
-        MergeTagsInput: {
             field: string;
             tags_to_merge: {
                 [key: string]: string;
@@ -14878,6 +15677,44 @@ export interface operations {
             };
         };
     };
+    /**
+     * Append tags to tag field.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:write"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    AppendTags: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["AppendTagsOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AppendTagsInput"];
+            };
+        };
+    };
     /**
      * Delete tags from tag field by tag value. tag field can be in format ["cat"], or [{"label":"cat"}]
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relevanceai/sdk",
-  "version": "1.98.0",
+  "version": "1.100.0",
   "description": "Javascript client for RelevanceAI APIs. Browser, Node.js and typescript support.",
   "main": "./dist-cjs/index.js",
   "types": "./dist-types/index.d.ts",