@relevanceai/sdk 1.115.0 → 1.117.0

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

@@ -1068,6 +1068,24 @@ export interface paths {
          */
         get: operations["ListProjectsInOrganization"];
     };
+    "/organizations/{organization_id}/metrics/aggregate": {
+        /**
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "organizations:read"
+         *     ],
+         *     "organizations": [
+         *       {
+         *         "params": "organization_id"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        post: operations["AggregateOrganizationMetrics"];
+    };
     "/connectors/create": {
         /**
          * ### Required permissions
@@ -1291,6 +1309,21 @@ export interface paths {
          */
         post: operations["DeleteWorkflowStatus"];
     };
+    "/workflows/{workflow_id}/terminate": {
+        /**
+         * Terminate a workflow
+         *
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "datasets:write"
+         *     ]
+         *   }
+         * ]
+         */
+        post: operations["TerminateWorkflow"];
+    };
     "/workflows/{workflow_id}/metadata": {
         /**
          * Update metadata for a workflow run
@@ -2048,6 +2081,26 @@ export interface paths {
          */
         post: operations["MergeTags"];
     };
+    "/datasets/{dataset_id}/tags/edit": {
+        /**
+         * Perform all tagging operations on a field in one payload.
+         *
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "datasets:write"
+         *     ],
+         *     "datasets": [
+         *       {
+         *         "params": "dataset_id"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        post: operations["EditTags"];
+    };
     "/datasets/{dataset_id}/facets": {
         /**
          * Takes a high level aggregation of every field, return their unique values and frequencies. This is used to help create the filter bar for search.
@@ -2517,6 +2570,90 @@ export interface paths {
          */
         post: operations["CreateComponent"];
     };
+    "/datasets/{dataset_id}/editor/history/list": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["ListDatasetEditorHistorys"];
+    };
+    "/datasets/{dataset_id}/editor/history/create": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["CreateDatasetEditorHistory"];
+    };
+    "/datasets/{dataset_id}/editor/configuration/list": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["ListDatasetEditorConfigurations"];
+    };
+    "/datasets/{dataset_id}/editor/configuration/create": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["CreateDatasetEditorConfiguration"];
+    };
+    "/datasets/{dataset_id}/editor/configuration/{dataseteditorconfiguration_id}/update": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["UpdateDatasetEditorConfiguration"];
+    };
+    "/datasets/{dataset_id}/editor/configuration/{dataseteditorconfiguration_id}/delete": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["DeleteDatasetEditorConfiguration"];
+    };
+    "/datasets/{dataset_id}/editor/configuration/{dataseteditorconfiguration_id}/get": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        get: operations["GetDatasetEditorConfiguration"];
+    };
+    "/datasets/{dataset_id}/fields/{field}/keyphrase/list": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["ListKeyphrases"];
+    };
+    "/datasets/{dataset_id}/fields/{field}/keyphrase/{keyphrase_id}/update": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["UpdateKeyphrase"];
+    };
+    "/datasets/{dataset_id}/fields/{field}/keyphrase/{keyphrase_id}/delete": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["DeleteKeyphrase"];
+    };
+    "/datasets/{dataset_id}/fields/{field}/keyphrase/{keyphrase_id}/get": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        get: operations["GetKeyphrase"];
+    };
+    "/datasets/{dataset_id}/fields/{field}/keyphrase/bulk_update": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["BulkUpdateKeyphrases"];
+    };
 }
 export interface components {
     schemas: {
@@ -2615,7 +2752,12 @@ export interface components {
         DeleteDeployableGroupInput: unknown;
         DeleteDeployableGroupOutput: unknown;
         ListDeployableGroupsInput: {
-            [key: string]: unknown;
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
         };
         ListDeployableGroupsOutput: {
             results: {
@@ -6389,59 +6531,606 @@ export interface components {
                 updated_at?: string;
             }[];
         };
-        CreateConnectorInput: {
-            source_type: "Snowflake";
-            source_database?: string;
-            source_collection: string;
-            /** @description If provided, use this field as the _id value in documents. */
-            id_field?: string;
-            source_settings: {
-                custom?: {
-                    [key: string]: unknown;
+        AggregateOrganizationMetricsInput: {
+            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[];
                 };
-                Snowflake?: {
-                    /** Authorization Method */
-                    credentials?: {
-                        /** @default OAuth */
-                        auth_type: string;
-                        /**
-                         * Client ID
-                         * @description The Client ID of your Snowflake developer application.
-                         */
-                        client_id: string;
+                /** @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?: {
                         /**
-                         * Client Secret
-                         * @description The Client Secret of your Snowflake developer application.
+                         * @description Increases or decreases the impact of all traditional search matching when calculating a documents _relevance.
+                         * @default 1
                          */
-                        client_secret: string;
+                        weight?: number;
                         /**
-                         * Access Token
-                         * @description Access Token for making authenticated requests.
+                         * @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
                          */
-                        access_token?: string;
+                        sentenceWeight?: number;
                         /**
-                         * Refresh Token
-                         * @description Refresh Token for making authenticated requests.
+                         * @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
                          */
-                        refresh_token?: string;
-                    } | {
-                        /** @default username/password */
-                        auth_type: string;
+                        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;
                         /**
-                         * Username
-                         * @description The username you created to allow Airbyte to access the database.
+                         * @description Model name to generate the vector with.
+                         * @default text
                          */
-                        username: string;
+                        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;
                         /**
-                         * Password
-                         * @description The password associated with the username.
+                         * @description Increases or decreases the impact of this vector fields match on documents relevance score.
+                         * @default 1
                          */
-                        password: string;
-                    };
-                    /**
-                     * Account Name
-                     * @description The host domain of the snowflake instance (must include the account, region, cloud environment, and end with snowflakecomputing.com).
-                     */
+                        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 Aggregation query to aggregate data */
+            aggregation_query?: {
+                groupby?: {
+                    agg?: "texts" | "categories" | "classes" | "text" | "category" | "class" | "terms" | "number" | "numeric" | "bool" | "wordcloud" | "array" | "boolean_filter" | "histogram";
+                    size?: number;
+                    field?: string;
+                    name?: string;
+                    boolean_filter?: 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 Control the number of results for this aggregation level. This will default to the page_size provided in the root body if not provided. */
+                    page_size?: number;
+                    group_size?: number;
+                    select_fields?: string[];
+                    remove_words?: string[];
+                    /** @default monthly */
+                    date_interval?: "monthly" | "daily" | "yearly" | "hourly" | "minutely" | "weekly";
+                    /** @description If provided, group by field into n buckets in date range. */
+                    n_date_buckets?: number;
+                    buckets?: Partial<{
+                        histogram?: {
+                            interval?: number;
+                            min_doc_count?: number;
+                        };
+                    }> & Partial<{
+                        from?: number;
+                        to?: number;
+                    }[]>;
+                }[];
+                metrics?: {
+                    field?: string;
+                    fields?: string[];
+                    agg?: "avg" | "average" | "cardinality" | "max" | "mean" | "min" | "sum" | "percentiles" | "sum_of_squares" | "variance" | "std_deviation" | "std_deviation_bounds" | "kurtosis" | "covariance" | "skewness" | "character_count" | "count" | "correlation" | "missing";
+                    name?: string;
+                }[];
+                sort?: (string | {
+                    [key: string]: "asc" | "desc";
+                })[];
+            };
+            /**
+             * @description Size of each page of results
+             * @default 20
+             */
+            page_size?: number;
+            /**
+             * @description Page of the results
+             * @default 1
+             */
+            page?: number;
+            /** @description Whether to sort results by ascending or descending order. */
+            asc?: boolean;
+            dataset_ids?: string[];
+            dataset_id?: string;
+            /** @default monthly */
+            date_interval?: "monthly" | "daily" | "yearly" | "hourly" | "minutely" | "weekly";
+        };
+        AggregateOrganizationMetricsOutput: {
+            results?: unknown[];
+        };
+        CreateConnectorInput: {
+            source_type: "Snowflake";
+            source_database?: string;
+            source_collection: string;
+            /** @description If provided, use this field as the _id value in documents. */
+            id_field?: string;
+            source_settings: {
+                custom?: {
+                    [key: string]: unknown;
+                };
+                Snowflake?: {
+                    /** Authorization Method */
+                    credentials?: {
+                        /** @default OAuth */
+                        auth_type: string;
+                        /**
+                         * Client ID
+                         * @description The Client ID of your Snowflake developer application.
+                         */
+                        client_id: string;
+                        /**
+                         * Client Secret
+                         * @description The Client Secret of your Snowflake developer application.
+                         */
+                        client_secret: string;
+                        /**
+                         * Access Token
+                         * @description Access Token for making authenticated requests.
+                         */
+                        access_token?: string;
+                        /**
+                         * Refresh Token
+                         * @description Refresh Token for making authenticated requests.
+                         */
+                        refresh_token?: string;
+                    } | {
+                        /** @default username/password */
+                        auth_type: string;
+                        /**
+                         * Username
+                         * @description The username you created to allow Airbyte to access the database.
+                         */
+                        username: string;
+                        /**
+                         * Password
+                         * @description The password associated with the username.
+                         */
+                        password: string;
+                    };
+                    /**
+                     * Account Name
+                     * @description The host domain of the snowflake instance (must include the account, region, cloud environment, and end with snowflakecomputing.com).
+                     */
                     host?: string;
                     /**
                      * Role
@@ -6927,6 +7616,20 @@ export interface components {
             instance_type?: string;
             dataset_id: string;
             workflow_id?: string;
+            template?: {
+                transformations: {
+                    [key: string]: {
+                        properties: {
+                            params: {
+                                [key: string]: unknown;
+                            };
+                            workflow_id: string;
+                            dataset_id: string;
+                        };
+                        depends_on?: string[];
+                    };
+                };
+            };
         };
         TriggerWorkflowOutput: {
             job_id: string;
@@ -6944,20 +7647,35 @@ export interface components {
                 };
                 _id?: string;
                 workflow_id?: string;
+                parent_job_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";
+                status?: "complete" | "inprogress" | "failed" | "cancelled";
+                job_status?: "InProgress" | "Completed" | "Failed" | "Cancelled";
                 worker_status?: {
                     [key: string]: {
-                        status?: "complete" | "inprogress" | "failed";
+                        status?: "complete" | "inprogress" | "failed" | "cancelled";
                         completion_time?: string;
                         creation_time?: string;
                     };
                 };
-                n_workers?: number;
+                n_workers?: number;
+                template?: {
+                    transformations: {
+                        [key: string]: {
+                            properties: {
+                                params: {
+                                    [key: string]: unknown;
+                                };
+                                workflow_id: string;
+                                dataset_id: string;
+                            };
+                            depends_on?: string[];
+                        };
+                    };
+                };
                 steps?: {
                     [key: string]: {
                         worker_progress?: {
@@ -6968,6 +7686,8 @@ export interface components {
                         };
                         n_processed?: number;
                         n_total?: number;
+                        job_id?: string;
+                        error_message?: string;
                     };
                 };
             } & {
@@ -6986,20 +7706,35 @@ export interface components {
             };
             _id?: string;
             workflow_id?: string;
+            parent_job_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";
+            status?: "complete" | "inprogress" | "failed" | "cancelled";
+            job_status?: "InProgress" | "Completed" | "Failed" | "Cancelled";
             worker_status?: {
                 [key: string]: {
-                    status?: "complete" | "inprogress" | "failed";
+                    status?: "complete" | "inprogress" | "failed" | "cancelled";
                     completion_time?: string;
                     creation_time?: string;
                 };
             };
             n_workers?: number;
+            template?: {
+                transformations: {
+                    [key: string]: {
+                        properties: {
+                            params: {
+                                [key: string]: unknown;
+                            };
+                            workflow_id: string;
+                            dataset_id: string;
+                        };
+                        depends_on?: string[];
+                    };
+                };
+            };
             steps?: {
                 [key: string]: {
                     worker_progress?: {
@@ -7010,6 +7745,8 @@ export interface components {
                     };
                     n_processed?: number;
                     n_total?: number;
+                    job_id?: string;
+                    error_message?: string;
                 };
             };
         } & {
@@ -7017,6 +7754,8 @@ export interface components {
         };
         DeleteWorkflowStatusInput: unknown;
         DeleteWorkflowStatusOutput: unknown;
+        TerminateWorkflowInput: unknown;
+        TerminateWorkflowOutput: unknown;
         UpsertWorkflowMetadataInput: {
             /** @description Edit and add metadata for the workflow. */
             metadata: {
@@ -7037,7 +7776,7 @@ export interface components {
                 [key: string]: unknown;
             };
             /** @description Status of the workflow. Used for knowing when to send an email notification. */
-            status: "complete" | "inprogress" | "failed";
+            status: "complete" | "inprogress" | "failed" | "cancelled";
             /** @description Workflow name that is passed into the email. */
             workflow_name?: string;
             /** @description Additional information of the workflow that is passed into the email. */
@@ -7060,20 +7799,35 @@ export interface components {
             };
             _id?: string;
             workflow_id?: string;
+            parent_job_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";
+            status?: "complete" | "inprogress" | "failed" | "cancelled";
+            job_status?: "InProgress" | "Completed" | "Failed" | "Cancelled";
             worker_status?: {
                 [key: string]: {
-                    status?: "complete" | "inprogress" | "failed";
+                    status?: "complete" | "inprogress" | "failed" | "cancelled";
                     completion_time?: string;
                     creation_time?: string;
                 };
             };
             n_workers?: number;
+            template?: {
+                transformations: {
+                    [key: string]: {
+                        properties: {
+                            params: {
+                                [key: string]: unknown;
+                            };
+                            workflow_id: string;
+                            dataset_id: string;
+                        };
+                        depends_on?: string[];
+                    };
+                };
+            };
             steps?: {
                 [key: string]: {
                     worker_progress?: {
@@ -7084,6 +7838,8 @@ export interface components {
                     };
                     n_processed?: number;
                     n_total?: number;
+                    job_id?: string;
+                    error_message?: string;
                 };
             };
         } & {
@@ -7094,6 +7850,9 @@ export interface components {
             results: ({
                 workflow_id: string;
                 workflow_path?: string;
+                template_raw_?: {
+                    [key: string]: unknown;
+                };
                 parameters_raw_?: {
                     [key: string]: unknown;
                 };
@@ -7105,6 +7864,9 @@ export interface components {
         GetWorkflowTypeOutput: {
             workflow_id: string;
             workflow_path?: string;
+            template_raw_?: {
+                [key: string]: unknown;
+            };
             parameters_raw_?: {
                 [key: string]: unknown;
             };
@@ -8169,38 +8931,295 @@ 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;
+                };
+            }[];
+        };
+        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;
                 };
-            }[];
-        };
-        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 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;
+            };
         };
-        UpdateWhereInput: {
+        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?: {
@@ -8446,18 +9465,11 @@ 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;
+            field: string;
+            tags_to_add: string[];
         };
-        AppendTagsInput: {
+        AppendTagsOutput: unknown;
+        DeleteTagsInput: {
             filters?: (Partial<{
                 /** @description Match where document[field] is in value list. */
                 match?: {
@@ -8704,10 +9716,10 @@ export interface components {
                 join?: boolean;
             }>)[];
             field: string;
-            tags_to_add: string[];
+            tags_to_delete: string[];
         };
-        AppendTagsOutput: unknown;
-        DeleteTagsInput: {
+        DeleteTagsOutput: unknown;
+        MergeTagsInput: {
             filters?: (Partial<{
                 /** @description Match where document[field] is in value list. */
                 match?: {
@@ -8954,10 +9966,12 @@ export interface components {
                 join?: boolean;
             }>)[];
             field: string;
-            tags_to_delete: string[];
+            tags_to_merge: {
+                [key: string]: string;
+            };
         };
-        DeleteTagsOutput: unknown;
-        MergeTagsInput: {
+        MergeTagsOutput: unknown;
+        EditTagsInput: {
             filters?: (Partial<{
                 /** @description Match where document[field] is in value list. */
                 match?: {
@@ -9204,11 +10218,13 @@ export interface components {
                 join?: boolean;
             }>)[];
             field: string;
-            tags_to_merge: {
+            tags_to_merge?: {
                 [key: string]: string;
             };
+            tags_to_delete?: string[];
+            tags_to_add?: string[];
         };
-        MergeTagsOutput: unknown;
+        EditTagsOutput: unknown;
         ListFacetsInput: {
             /** @description Fields to include in the facets, if [] then all */
             fields?: string[];
@@ -12015,7 +13031,12 @@ export interface components {
         DeleteFieldChildrenInput: unknown;
         DeleteFieldChildrenOutput: unknown;
         ListFieldChildrensInput: {
-            [key: string]: unknown;
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
         };
         ListFieldChildrensOutput: {
             results: {
@@ -12041,7 +13062,12 @@ export interface components {
         DeleteFavouriteWorkflowInput: unknown;
         DeleteFavouriteWorkflowOutput: unknown;
         ListFavouriteWorkflowsInput: {
-            [key: string]: unknown;
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
         };
         ListFavouriteWorkflowsOutput: {
             results: {
@@ -12055,7 +13081,12 @@ export interface components {
         DeleteSavedFilterInput: unknown;
         DeleteSavedFilterOutput: unknown;
         ListSavedFiltersInput: {
-            [key: string]: unknown;
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
         };
         ListSavedFiltersOutput: {
             results: {
@@ -12099,7 +13130,12 @@ export interface components {
         DeleteComponentInput: unknown;
         DeleteComponentOutput: unknown;
         ListComponentsInput: {
-            [key: string]: unknown;
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
         };
         ListComponentsOutput: {
             results: {
@@ -12132,6 +13168,145 @@ export interface components {
         CreateComponentOutput: {
             id: string;
         };
+        ListDatasetEditorHistorysInput: {
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
+        };
+        ListDatasetEditorHistorysOutput: {
+            results: {
+                _id?: string;
+                metadata?: {
+                    [key: string]: unknown;
+                };
+                items?: {
+                    [key: string]: {
+                        updates?: unknown[];
+                        filters?: unknown[];
+                    };
+                };
+            }[];
+        };
+        CreateDatasetEditorHistoryInput: {
+            _id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            items?: {
+                [key: string]: {
+                    updates?: unknown[];
+                    filters?: unknown[];
+                };
+            };
+        };
+        CreateDatasetEditorHistoryOutput: {
+            id: string;
+        };
+        ListDatasetEditorConfigurationsInput: {
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
+        };
+        ListDatasetEditorConfigurationsOutput: {
+            results: {
+                _id?: string;
+                metadata?: {
+                    [key: string]: unknown;
+                };
+                items?: {
+                    [key: string]: {
+                        updates?: unknown[];
+                        filters?: unknown[];
+                    };
+                };
+            }[];
+        };
+        CreateDatasetEditorConfigurationInput: {
+            _id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            items?: {
+                [key: string]: {
+                    updates?: unknown[];
+                    filters?: unknown[];
+                };
+            };
+        };
+        CreateDatasetEditorConfigurationOutput: {
+            id: string;
+        };
+        UpdateDatasetEditorConfigurationInput: {
+            _id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            items?: {
+                [key: string]: {
+                    updates?: unknown[];
+                    filters?: unknown[];
+                };
+            };
+        };
+        UpdateDatasetEditorConfigurationOutput: unknown;
+        DeleteDatasetEditorConfigurationInput: unknown;
+        DeleteDatasetEditorConfigurationOutput: unknown;
+        GetDatasetEditorConfigurationInput: unknown;
+        GetDatasetEditorConfigurationOutput: {
+            _id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            items?: {
+                [key: string]: {
+                    updates?: unknown[];
+                    filters?: unknown[];
+                };
+            };
+        };
+        ListKeyphrasesInput: {
+            page?: number;
+            page_size?: number;
+            /** @description Fields to sort by. For each field, sort by descending or ascending. If you are using descending by datetime, it will get the most recent ones. */
+            sort?: (string | {
+                [key: string]: "asc" | "desc";
+            })[];
+        };
+        ListKeyphrasesOutput: {
+            results: {
+                _id?: string;
+                keyphrase?: string;
+                score?: number;
+            }[];
+        };
+        UpdateKeyphraseInput: {
+            _id?: string;
+            keyphrase?: string;
+            score?: number;
+        };
+        UpdateKeyphraseOutput: unknown;
+        DeleteKeyphraseInput: unknown;
+        DeleteKeyphraseOutput: unknown;
+        GetKeyphraseInput: unknown;
+        GetKeyphraseOutput: {
+            _id?: string;
+            keyphrase?: string;
+            score?: number;
+        };
+        BulkUpdateKeyphrasesInput: {
+            updates?: {
+                _id?: string;
+                keyphrase?: string;
+                score?: number;
+            }[];
+        };
+        BulkUpdateKeyphrasesOutput: unknown;
     };
 }
 export interface operations {
@@ -14422,6 +15597,42 @@ export interface operations {
             };
         };
     };
+    /**
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "organizations:read"
+     *     ],
+     *     "organizations": [
+     *       {
+     *         "params": "organization_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    AggregateOrganizationMetrics: {
+        parameters: {
+            path: {
+                /** ID of organization */
+                organization_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["AggregateOrganizationMetricsOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AggregateOrganizationMetricsInput"];
+            };
+        };
+    };
     /**
      * ### Required permissions
      * > [
@@ -14871,6 +16082,39 @@ export interface operations {
             };
         };
     };
+    /**
+     * Terminate a workflow
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:write"
+     *     ]
+     *   }
+     * ]
+     */
+    TerminateWorkflow: {
+        parameters: {
+            path: {
+                /** ID of workflow */
+                workflow_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["TerminateWorkflowOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TerminateWorkflowInput"];
+            };
+        };
+    };
     /**
      * Update metadata for a workflow run
      *
@@ -16501,6 +17745,44 @@ export interface operations {
             };
         };
     };
+    /**
+     * Perform all tagging operations on a field in one payload.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:write"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    EditTags: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["EditTagsOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EditTagsInput"];
+            };
+        };
+    };
     /**
      * Takes a high level aggregation of every field, return their unique values and frequencies. This is used to help create the filter bar for search.
      *
@@ -17343,57 +18625,310 @@ export interface operations {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["ListDocumentsOutput"];
+                    "application/json": components["schemas"]["ListDocumentsOutput"];
+                };
+            };
+        };
+    };
+    /**
+     * Delete documents that match on a filters. At least one filter must be provided.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:write"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    DeleteWhere: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["DeleteWhereOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DeleteWhereInput"];
+            };
+        };
+    };
+    /**
+     * SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    SimpleSearchPost: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["SimpleSearchPostOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SimpleSearchPostInput"];
+            };
+        };
+    };
+    /**
+     * SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    Search: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["SearchOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SearchInput"];
+            };
+        };
+    };
+    /**
+     * Recommend documents similar to specific documents. Specify which vector field must be used for recommendation using  the documentsToRecommend property.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    Recommend: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["RecommendOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RecommendInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   },
+     *   {
+     *     "actions": [
+     *       "datasets:write"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "body": "new_dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    CloneDataset: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["CloneDatasetOutput"];
                 };
             };
         };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CloneDatasetInput"];
+            };
+        };
     };
     /**
-     * Delete documents that match on a filters. At least one filter must be provided.
+     * Predict using KNN regression.
      *
      * ### Required permissions
      * > [
      *   {
      *     "actions": [
-     *       "datasets:write"
+     *       "datasets:read"
      *     ],
      *     "datasets": [
      *       {
-     *         "params": "dataset_id"
+     *         "body": "dataset_id"
      *       }
      *     ]
      *   }
      * ]
      */
-    DeleteWhere: {
-        parameters: {
-            path: {
-                /** ID of dataset */
-                dataset_id: string;
+    PredictKNNRegression: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["PredictKNNRegressionOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PredictKNNRegressionInput"];
             };
         };
+    };
+    /**
+     * Predict using KNN regression from search results.
+     *
+     * ### Required permissions
+     * > []
+     */
+    PredictKNNFromResults: {
+        parameters: {};
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["DeleteWhereOutput"];
+                    "application/json": components["schemas"]["PredictKNNFromResultsOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["DeleteWhereInput"];
+                "application/json": components["schemas"]["PredictKNNFromResultsInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    BiasEvaluation: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["BiasEvaluationOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["BiasEvaluationInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    Vectorize: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["VectorizeOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["VectorizeInput"];
             };
         };
     };
     /**
-     * SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
-     *
      * ### Required permissions
      * > [
      *   {
      *     "actions": [
-     *       "datasets:read"
+     *       "datasets:write"
      *     ],
      *     "datasets": [
      *       {
@@ -17403,7 +18938,7 @@ export interface operations {
      *   }
      * ]
      */
-    SimpleSearchPost: {
+    VectorizeAndInsert: {
         parameters: {
             path: {
                 /** ID of dataset */
@@ -17414,24 +18949,22 @@ export interface operations {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["SimpleSearchPostOutput"];
+                    "application/json": components["schemas"]["VectorizeAndInsertOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["SimpleSearchPostInput"];
+                "application/json": components["schemas"]["VectorizeAndInsertInput"];
             };
         };
     };
     /**
-     * SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
-     *
      * ### Required permissions
      * > [
      *   {
      *     "actions": [
-     *       "datasets:read"
+     *       "datasets:write"
      *     ],
      *     "datasets": [
      *       {
@@ -17441,7 +18974,7 @@ export interface operations {
      *   }
      * ]
      */
-    Search: {
+    VectorizeField: {
         parameters: {
             path: {
                 /** ID of dataset */
@@ -17452,80 +18985,68 @@ export interface operations {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["SearchOutput"];
+                    "application/json": components["schemas"]["VectorizeFieldOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["SearchInput"];
+                "application/json": components["schemas"]["VectorizeFieldInput"];
             };
         };
     };
     /**
-     * Recommend documents similar to specific documents. Specify which vector field must be used for recommendation using  the documentsToRecommend property.
-     *
      * ### Required permissions
-     * > [
-     *   {
-     *     "actions": [
-     *       "datasets:read"
-     *     ],
-     *     "datasets": [
-     *       {
-     *         "params": "dataset_id"
-     *       }
-     *     ]
-     *   }
-     * ]
+     * > []
      */
-    Recommend: {
+    CreateImageFromPrompt: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["CreateImageFromPromptOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateImageFromPromptInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    DeleteFieldChildren: {
         parameters: {
             path: {
                 /** ID of dataset */
                 dataset_id: string;
+                /** ID of fieldchildren */
+                fieldchildren_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["RecommendOutput"];
+                    "application/json": components["schemas"]["DeleteFieldChildrenOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["RecommendInput"];
+                "application/json": components["schemas"]["DeleteFieldChildrenInput"];
             };
         };
     };
     /**
      * ### Required permissions
-     * > [
-     *   {
-     *     "actions": [
-     *       "datasets:read"
-     *     ],
-     *     "datasets": [
-     *       {
-     *         "params": "dataset_id"
-     *       }
-     *     ]
-     *   },
-     *   {
-     *     "actions": [
-     *       "datasets:write"
-     *     ],
-     *     "datasets": [
-     *       {
-     *         "body": "new_dataset_id"
-     *       }
-     *     ]
-     *   }
-     * ]
+     * > []
      */
-    CloneDataset: {
+    ListFieldChildrens: {
         parameters: {
             path: {
                 /** ID of dataset */
@@ -17536,68 +19057,110 @@ export interface operations {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["CloneDatasetOutput"];
+                    "application/json": components["schemas"]["ListFieldChildrensOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CloneDatasetInput"];
+                "application/json": components["schemas"]["ListFieldChildrensInput"];
             };
         };
     };
     /**
-     * Predict using KNN regression.
-     *
      * ### Required permissions
-     * > [
-     *   {
-     *     "actions": [
-     *       "datasets:read"
-     *     ],
-     *     "datasets": [
-     *       {
-     *         "body": "dataset_id"
-     *       }
-     *     ]
-     *   }
-     * ]
+     * > []
      */
-    PredictKNNRegression: {
-        parameters: {};
+    UpdateFieldChildren: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of fieldchildren */
+                fieldchildren_id: string;
+            };
+        };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["PredictKNNRegressionOutput"];
+                    "application/json": components["schemas"]["UpdateFieldChildrenOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["PredictKNNRegressionInput"];
+                "application/json": components["schemas"]["UpdateFieldChildrenInput"];
             };
         };
     };
     /**
-     * Predict using KNN regression from search results.
-     *
      * ### Required permissions
      * > []
      */
-    PredictKNNFromResults: {
+    DeleteFavouriteWorkflow: {
+        parameters: {
+            path: {
+                /** ID of favouriteworkflow */
+                favouriteworkflow_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["DeleteFavouriteWorkflowOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DeleteFavouriteWorkflowInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    ListFavouriteWorkflows: {
         parameters: {};
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["PredictKNNFromResultsOutput"];
+                    "application/json": components["schemas"]["ListFavouriteWorkflowsOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ListFavouriteWorkflowsInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    UpdateFavouriteWorkflow: {
+        parameters: {
+            path: {
+                /** ID of favouriteworkflow */
+                favouriteworkflow_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["UpdateFavouriteWorkflowOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["PredictKNNFromResultsInput"];
+                "application/json": components["schemas"]["UpdateFavouriteWorkflowInput"];
             };
         };
     };
@@ -17605,19 +19168,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    BiasEvaluation: {
-        parameters: {};
+    DeleteSavedFilter: {
+        parameters: {
+            path: {
+                /** ID of savedfilter */
+                savedfilter_id: string;
+            };
+        };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["BiasEvaluationOutput"];
+                    "application/json": components["schemas"]["DeleteSavedFilterOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["BiasEvaluationInput"];
+                "application/json": components["schemas"]["DeleteSavedFilterInput"];
             };
         };
     };
@@ -17625,111 +19193,84 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    Vectorize: {
+    ListSavedFilters: {
         parameters: {};
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["VectorizeOutput"];
+                    "application/json": components["schemas"]["ListSavedFiltersOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["VectorizeInput"];
+                "application/json": components["schemas"]["ListSavedFiltersInput"];
             };
         };
     };
     /**
      * ### Required permissions
-     * > [
-     *   {
-     *     "actions": [
-     *       "datasets:write"
-     *     ],
-     *     "datasets": [
-     *       {
-     *         "params": "dataset_id"
-     *       }
-     *     ]
-     *   }
-     * ]
+     * > []
      */
-    VectorizeAndInsert: {
+    UpdateSavedFilter: {
         parameters: {
             path: {
-                /** ID of dataset */
-                dataset_id: string;
+                /** ID of savedfilter */
+                savedfilter_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["VectorizeAndInsertOutput"];
+                    "application/json": components["schemas"]["UpdateSavedFilterOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["VectorizeAndInsertInput"];
+                "application/json": components["schemas"]["UpdateSavedFilterInput"];
             };
         };
     };
     /**
      * ### Required permissions
-     * > [
-     *   {
-     *     "actions": [
-     *       "datasets:write"
-     *     ],
-     *     "datasets": [
-     *       {
-     *         "params": "dataset_id"
-     *       }
-     *     ]
-     *   }
-     * ]
+     * > []
      */
-    VectorizeField: {
+    GetSavedFilter: {
         parameters: {
             path: {
-                /** ID of dataset */
-                dataset_id: string;
+                /** ID of savedfilter */
+                savedfilter_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["VectorizeFieldOutput"];
+                    "application/json": components["schemas"]["GetSavedFilterOutput"];
                 };
             };
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["VectorizeFieldInput"];
-            };
-        };
     };
     /**
      * ### Required permissions
      * > []
      */
-    CreateImageFromPrompt: {
+    CreateSavedFilter: {
         parameters: {};
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["CreateImageFromPromptOutput"];
+                    "application/json": components["schemas"]["CreateSavedFilterOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CreateImageFromPromptInput"];
+                "application/json": components["schemas"]["CreateSavedFilterInput"];
             };
         };
     };
@@ -17737,26 +19278,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    DeleteFieldChildren: {
+    DeleteComponent: {
         parameters: {
             path: {
-                /** ID of dataset */
-                dataset_id: string;
-                /** ID of fieldchildren */
-                fieldchildren_id: string;
+                /** ID of component */
+                component_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["DeleteFieldChildrenOutput"];
+                    "application/json": components["schemas"]["DeleteComponentOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["DeleteFieldChildrenInput"];
+                "application/json": components["schemas"]["DeleteComponentInput"];
             };
         };
     };
@@ -17764,24 +19303,19 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    ListFieldChildrens: {
-        parameters: {
-            path: {
-                /** ID of dataset */
-                dataset_id: string;
-            };
-        };
+    ListComponents: {
+        parameters: {};
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["ListFieldChildrensOutput"];
+                    "application/json": components["schemas"]["ListComponentsOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ListFieldChildrensInput"];
+                "application/json": components["schemas"]["ListComponentsInput"];
             };
         };
     };
@@ -17789,26 +19323,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    UpdateFieldChildren: {
+    UpdateComponent: {
         parameters: {
             path: {
-                /** ID of dataset */
-                dataset_id: string;
-                /** ID of fieldchildren */
-                fieldchildren_id: string;
+                /** ID of component */
+                component_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["UpdateFieldChildrenOutput"];
+                    "application/json": components["schemas"]["UpdateComponentOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["UpdateFieldChildrenInput"];
+                "application/json": components["schemas"]["UpdateComponentInput"];
             };
         };
     };
@@ -17816,44 +19348,39 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    DeleteFavouriteWorkflow: {
+    GetComponent: {
         parameters: {
             path: {
-                /** ID of favouriteworkflow */
-                favouriteworkflow_id: string;
+                /** ID of component */
+                component_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["DeleteFavouriteWorkflowOutput"];
+                    "application/json": components["schemas"]["GetComponentOutput"];
                 };
             };
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["DeleteFavouriteWorkflowInput"];
-            };
-        };
     };
     /**
      * ### Required permissions
      * > []
      */
-    ListFavouriteWorkflows: {
+    CreateComponent: {
         parameters: {};
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["ListFavouriteWorkflowsOutput"];
+                    "application/json": components["schemas"]["CreateComponentOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ListFavouriteWorkflowsInput"];
+                "application/json": components["schemas"]["CreateComponentInput"];
             };
         };
     };
@@ -17861,24 +19388,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    UpdateFavouriteWorkflow: {
+    ListDatasetEditorHistorys: {
         parameters: {
             path: {
-                /** ID of favouriteworkflow */
-                favouriteworkflow_id: string;
+                /** ID of dataset */
+                dataset_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["UpdateFavouriteWorkflowOutput"];
+                    "application/json": components["schemas"]["ListDatasetEditorHistorysOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["UpdateFavouriteWorkflowInput"];
+                "application/json": components["schemas"]["ListDatasetEditorHistorysInput"];
             };
         };
     };
@@ -17886,24 +19413,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    DeleteSavedFilter: {
+    CreateDatasetEditorHistory: {
         parameters: {
             path: {
-                /** ID of savedfilter */
-                savedfilter_id: string;
+                /** ID of dataset */
+                dataset_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["DeleteSavedFilterOutput"];
+                    "application/json": components["schemas"]["CreateDatasetEditorHistoryOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["DeleteSavedFilterInput"];
+                "application/json": components["schemas"]["CreateDatasetEditorHistoryInput"];
             };
         };
     };
@@ -17911,19 +19438,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    ListSavedFilters: {
-        parameters: {};
+    ListDatasetEditorConfigurations: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["ListSavedFiltersOutput"];
+                    "application/json": components["schemas"]["ListDatasetEditorConfigurationsOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ListSavedFiltersInput"];
+                "application/json": components["schemas"]["ListDatasetEditorConfigurationsInput"];
             };
         };
     };
@@ -17931,24 +19463,24 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    UpdateSavedFilter: {
+    CreateDatasetEditorConfiguration: {
         parameters: {
             path: {
-                /** ID of savedfilter */
-                savedfilter_id: string;
+                /** ID of dataset */
+                dataset_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["UpdateSavedFilterOutput"];
+                    "application/json": components["schemas"]["CreateDatasetEditorConfigurationOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["UpdateSavedFilterInput"];
+                "application/json": components["schemas"]["CreateDatasetEditorConfigurationInput"];
             };
         };
     };
@@ -17956,39 +19488,53 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    GetSavedFilter: {
+    UpdateDatasetEditorConfiguration: {
         parameters: {
             path: {
-                /** ID of savedfilter */
-                savedfilter_id: string;
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of dataseteditorconfiguration */
+                dataseteditorconfiguration_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["GetSavedFilterOutput"];
+                    "application/json": components["schemas"]["UpdateDatasetEditorConfigurationOutput"];
                 };
             };
         };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateDatasetEditorConfigurationInput"];
+            };
+        };
     };
     /**
      * ### Required permissions
      * > []
      */
-    CreateSavedFilter: {
-        parameters: {};
+    DeleteDatasetEditorConfiguration: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of dataseteditorconfiguration */
+                dataseteditorconfiguration_id: string;
+            };
+        };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["CreateSavedFilterOutput"];
+                    "application/json": components["schemas"]["DeleteDatasetEditorConfigurationOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CreateSavedFilterInput"];
+                "application/json": components["schemas"]["DeleteDatasetEditorConfigurationInput"];
             };
         };
     };
@@ -17996,24 +19542,48 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    DeleteComponent: {
+    GetDatasetEditorConfiguration: {
         parameters: {
             path: {
-                /** ID of component */
-                component_id: string;
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of dataseteditorconfiguration */
+                dataseteditorconfiguration_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["DeleteComponentOutput"];
+                    "application/json": components["schemas"]["GetDatasetEditorConfigurationOutput"];
+                };
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    ListKeyphrases: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of field */
+                field: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["ListKeyphrasesOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["DeleteComponentInput"];
+                "application/json": components["schemas"]["ListKeyphrasesInput"];
             };
         };
     };
@@ -18021,19 +19591,28 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    ListComponents: {
-        parameters: {};
+    UpdateKeyphrase: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of field */
+                field: string;
+                /** ID of keyphrase */
+                keyphrase_id: string;
+            };
+        };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["ListComponentsOutput"];
+                    "application/json": components["schemas"]["UpdateKeyphraseOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["ListComponentsInput"];
+                "application/json": components["schemas"]["UpdateKeyphraseInput"];
             };
         };
     };
@@ -18041,24 +19620,28 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    UpdateComponent: {
+    DeleteKeyphrase: {
         parameters: {
             path: {
-                /** ID of component */
-                component_id: string;
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of field */
+                field: string;
+                /** ID of keyphrase */
+                keyphrase_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["UpdateComponentOutput"];
+                    "application/json": components["schemas"]["DeleteKeyphraseOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["UpdateComponentInput"];
+                "application/json": components["schemas"]["DeleteKeyphraseInput"];
             };
         };
     };
@@ -18066,18 +19649,22 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    GetComponent: {
+    GetKeyphrase: {
         parameters: {
             path: {
-                /** ID of component */
-                component_id: string;
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of field */
+                field: string;
+                /** ID of keyphrase */
+                keyphrase_id: string;
             };
         };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["GetComponentOutput"];
+                    "application/json": components["schemas"]["GetKeyphraseOutput"];
                 };
             };
         };
@@ -18086,19 +19673,26 @@ export interface operations {
      * ### Required permissions
      * > []
      */
-    CreateComponent: {
-        parameters: {};
+    BulkUpdateKeyphrases: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+                /** ID of field */
+                field: string;
+            };
+        };
         responses: {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["CreateComponentOutput"];
+                    "application/json": components["schemas"]["BulkUpdateKeyphrasesOutput"];
                 };
             };
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CreateComponentInput"];
+                "application/json": components["schemas"]["BulkUpdateKeyphrasesInput"];
             };
         };
     };