@relevanceai/sdk 1.107.0 → 1.108.0

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

@@ -2112,6 +2112,43 @@ export interface paths {
          */
         post: operations["PaginateDocuments"];
     };
+    "/datasets/{dataset_id}/summaries/create": {
+        /**
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "datasets:read",
+         *       "datasets:write"
+         *     ],
+         *     "datasets": [
+         *       {
+         *         "params": "dataset_id"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        post: operations["CreateDatasetSummary"];
+    };
+    "/datasets/{dataset_id}/summaries/history/list": {
+        /**
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "datasets:read"
+         *     ],
+         *     "datasets": [
+         *       {
+         *         "params": "dataset_id"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        get: operations["ListDatasetSummaryHistory"];
+    };
     "/datasets/{dataset_id}/documents/bulk_get": {
         /**
          * Retrieve documents by their IDs ("_id" field). This will retrieve the documents faster than a filter applied on the "_id" field. For single id lookup version of this request use /datasets/{dataset_id}/documents/get.
@@ -2445,6 +2482,41 @@ export interface paths {
          */
         post: operations["CreateSavedFilter"];
     };
+    "/components/{component_id}/delete": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["DeleteComponent"];
+    };
+    "/components/list": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["ListComponents"];
+    };
+    "/components/{component_id}/update": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["UpdateComponent"];
+    };
+    "/components/{component_id}/get": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        get: operations["GetComponent"];
+    };
+    "/components/create": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["CreateComponent"];
+    };
 }
 export interface components {
     schemas: {
@@ -3898,6 +3970,8 @@ export interface components {
                     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;
@@ -4441,6 +4515,8 @@ export interface components {
                     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;
@@ -5027,6 +5103,8 @@ export interface components {
                     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;
@@ -6191,6 +6269,12 @@ export interface components {
             alias?: string;
             dataset_id?: string;
             cluster_ids: unknown[];
+            /** @description Whether to optionally only delete summaries matching the question suffix. */
+            question_suffix?: string;
+            /** @description Whether to optionally only delete summaries matching the question prefix. */
+            question_prefix?: string;
+            /** @description Whether to optionally only delete summaries matching the field. */
+            field?: string;
         };
         DeleteClusterSummariesOutput: unknown;
         CreateOrganizationInput: {
@@ -7010,7 +7094,7 @@ export interface components {
             results: ({
                 workflow_id: string;
                 workflow_path?: string;
-                parameters?: {
+                parameters_raw_?: {
                     [key: string]: unknown;
                 };
             } & {
@@ -7021,7 +7105,7 @@ export interface components {
         GetWorkflowTypeOutput: {
             workflow_id: string;
             workflow_path?: string;
-            parameters?: {
+            parameters_raw_?: {
                 [key: string]: unknown;
             };
         } & {
@@ -7251,6 +7335,8 @@ export interface components {
              * @default true
              */
             ingest_in_background?: boolean;
+            /** @description Whether to parse this blob in a workflow for csv files only. Required for csv files larger than 30mb. */
+            run_csv_workflow?: boolean;
         };
         ParseBlobOutput: {
             status: string;
@@ -9733,181 +9819,462 @@ export interface components {
             /** @description Used in future requests to retrieve items after these values in the sort order. */
             after_id: unknown[];
         };
-        BulkGetDocumentsInput: {
-            /** @description IDs of documents to retrieve */
-            ids: string[];
-            /** @description Fields to include in the search results, empty array/list means all fields. */
-            select_fields?: string[];
-            /** @description Include vectors in the search results */
-            include_vector?: boolean;
-        };
-        BulkGetDocumentsOutput: {
-            /** @description A list of documents. Document is a JSON-like data that we store our metadata and vectors with. For specifying id of the document use the field '_id', for specifying vector field use the suffix of '_vector_' */
-            documents: unknown[];
-        };
-        BulkDeleteDocumentsInput: {
-            /** @description IDs of documents to delete */
-            ids: string[];
-        };
-        BulkDeleteDocumentsOutput: unknown;
-        ListDocumentsInput: unknown;
-        ListDocumentsOutput: {
-            count: number;
-            /**
-             * @description List of documents. List items are affected by page, pageSize, query, filters. Items order is affected by vectorSeachQuery, sort, textSort.
-             *
-             *     Example: [{"_id":"abcd","animal":"cat","price":10}, {"_id":"abcd","price":13}]
-             */
-            documents: {
-                /** @description Measures how closely a document matches on query and vectorSearchQuery. */
-                _relevance?: number;
-                _chunk_results?: {
-                    [key: string]: {
-                        results: {
-                            _relevance?: number;
-                        }[];
-                        _relevance: number;
-                    };
+        CreateDatasetSummaryInput: {
+            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 Used in future requests to retrieve items after these values in the sort order. */
-            after_id: unknown[];
-        };
-        DeleteWhereInput: {
-            [key: string]: unknown;
-        } & {
-            filters: unknown;
-        };
-        DeleteWhereOutput: {
-            /** @description Completion status. */
-            status: string;
-            /** @description Response message for completion state. */
-            message: string;
-        };
-        /**
-         * @description Control which fields aggregate data will be generated for. Aggregate data will appear in the "aggregates" property of the response body.
-         *
-         *     Each list element can be a string like "name" or a dictionary like {"field":"name","resultsSize":11}
-         *
-         *     Default: []
-         *
-         *     Example: ["name","price","likes_cats",{"field":"color","resultsSize":20}]
-         */
-        fieldsToAggregate: (string | {
-            /** @description Field to aggregate. */
-            field?: string;
-            /** @description Controls which field the aggregate output will be placed into. */
-            outputField?: string;
-            /**
-             * @description Number of top aggregate results to return.
-             * @default 10
-             */
-            resultsSize?: number;
-            /**
-             * @description Sort aggregation results by count ascending or descending.
-             * @default desc
-             */
-            sort?: "asc" | "desc";
-            page?: number;
-            fieldsToAggregate?: components["schemas"]["fieldsToAggregate"];
-            /** @description Whether to retrieve min, max, avg and sum stats for the field as well */
-            getStats?: boolean;
-            dateAggregate?: {
-                /** @default monthly */
-                date_interval?: "monthly" | "daily" | "yearly" | "hourly" | "minutely" | "weekly";
-            };
-            /** @description Retrieve documents for each aggregated category. use 'pageSize' to control the number of documents to retrieve, and 'includeFields' to only return certain fields. */
-            getDocuments?: {
-                pageSize?: number;
-                includeFields?: string[];
-            };
-            chunkAggregate?: {
-                chunkFieldName: string;
-                filters?: components["schemas"]["simpleSearchAndFlatFilterItem"][];
-            };
-        })[];
-        /**
-         * @description Control which fields aggregate stats data will be generated for. This includes, min value, max value, average value, and document counts per interval within the dataset.
-         *
-         *     Aggregate data will appear in the "aggregateStats" property of the response body.
-         *
-         *     Each list item can be:
-         *
-         *      a string stating which field to aggregate stats on
-         *
-         *     An object containing "field" to pick a field, and "interval" to control the range of each bucket when counting documents:
-         *
-         *     For example, if we had products {"price":50},{"price:"150"},{price:"180"},{"field":"price","interval":100}  would split results into 2 buckets.
-         *
-         *     Default: []
-         *     Example: ["postcode",{"field":"price","interval":10}]
-         */
-        fieldsToAggregateStats: (string | {
-            /** @description Field to return stats for in aggregateStats. */
-            field?: string;
-            /** @description Interval gap when building a histogram. An interval of 2 will count documents in range 0-2,2-4,4-6... */
-            interval?: number;
-            /** @description Controls which field the aggregate output will be placed into. */
-            outputField?: string;
-        })[];
-        simpleSearchFilterItem: {
-            /** @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.
+                 * @description
+                 * Match documents where the field either contains the value as a substring, or matches a provided matching pattern.
                  *
-                 *     "tele" matches "Television", "This television is an excellent product…"
+                 * Possible matching patterns:
                  *
-                 *     Example: "tele"
-                 */
-                query?: string;
+                 * * - 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 Fields to include in the search results, empty array/list means all fields. */
+            select_fields?: string[];
+            /** @description Size of each page of results. */
+            page_size?: number;
+            /** @description Size of each page of results. */
+            page?: 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";
+            })[];
+            /** @description Include vectors in the search results. */
+            include_vector?: boolean;
+            /** @description (NOT IMPLEMENTED - not functional) If true, retrieves documents randomly. */
+            is_random?: boolean;
+            /** @description (NOT IMPLEMENTED - not functional)Random Seed for retrieving random documents. */
+            random_state?: number;
+            /** @description Retrieve items after these sort values in the sort order. */
+            after_id?: unknown[];
+            question: string;
+            field: string;
+        };
+        CreateDatasetSummaryOutput: {
+            question: string;
+            answer: string;
+        };
+        ListDatasetSummaryHistoryInput: unknown;
+        ListDatasetSummaryHistoryOutput: {
+            results: {
+                question?: string;
+                prompt?: string;
+                field?: string;
+                answer?: string;
+                dataset?: string;
+            }[];
+        };
+        BulkGetDocumentsInput: {
+            /** @description IDs of documents to retrieve */
+            ids: string[];
+            /** @description Fields to include in the search results, empty array/list means all fields. */
+            select_fields?: string[];
+            /** @description Include vectors in the search results */
+            include_vector?: boolean;
+        };
+        BulkGetDocumentsOutput: {
+            /** @description A list of documents. Document is a JSON-like data that we store our metadata and vectors with. For specifying id of the document use the field '_id', for specifying vector field use the suffix of '_vector_' */
+            documents: unknown[];
+        };
+        BulkDeleteDocumentsInput: {
+            /** @description IDs of documents to delete */
+            ids: string[];
+        };
+        BulkDeleteDocumentsOutput: unknown;
+        ListDocumentsInput: unknown;
+        ListDocumentsOutput: {
+            count: number;
+            /**
+             * @description List of documents. List items are affected by page, pageSize, query, filters. Items order is affected by vectorSeachQuery, sort, textSort.
+             *
+             *     Example: [{"_id":"abcd","animal":"cat","price":10}, {"_id":"abcd","price":13}]
+             */
+            documents: {
+                /** @description Measures how closely a document matches on query and vectorSearchQuery. */
+                _relevance?: number;
+                _chunk_results?: {
+                    [key: string]: {
+                        results: {
+                            _relevance?: number;
+                        }[];
+                        _relevance: number;
+                    };
+                };
+            }[];
+            /** @description Used in future requests to retrieve items after these values in the sort order. */
+            after_id: unknown[];
+        };
+        DeleteWhereInput: {
+            [key: string]: unknown;
+        } & {
+            filters: unknown;
+        };
+        DeleteWhereOutput: {
+            /** @description Completion status. */
+            status: string;
+            /** @description Response message for completion state. */
+            message: string;
+        };
+        /**
+         * @description Control which fields aggregate data will be generated for. Aggregate data will appear in the "aggregates" property of the response body.
+         *
+         *     Each list element can be a string like "name" or a dictionary like {"field":"name","resultsSize":11}
+         *
+         *     Default: []
+         *
+         *     Example: ["name","price","likes_cats",{"field":"color","resultsSize":20}]
+         */
+        fieldsToAggregate: (string | {
+            /** @description Field to aggregate. */
+            field?: string;
+            /** @description Controls which field the aggregate output will be placed into. */
+            outputField?: string;
+            /**
+             * @description Number of top aggregate results to return.
+             * @default 10
+             */
+            resultsSize?: number;
+            /**
+             * @description Sort aggregation results by count ascending or descending.
+             * @default desc
+             */
+            sort?: "asc" | "desc";
+            page?: number;
+            fieldsToAggregate?: components["schemas"]["fieldsToAggregate"];
+            /** @description Whether to retrieve min, max, avg and sum stats for the field as well */
+            getStats?: boolean;
+            dateAggregate?: {
+                /** @default monthly */
+                date_interval?: "monthly" | "daily" | "yearly" | "hourly" | "minutely" | "weekly";
+            };
+            /** @description Retrieve documents for each aggregated category. use 'pageSize' to control the number of documents to retrieve, and 'includeFields' to only return certain fields. */
+            getDocuments?: {
+                pageSize?: number;
+                includeFields?: string[];
+            };
+            chunkAggregate?: {
+                chunkFieldName: string;
+                filters?: components["schemas"]["simpleSearchAndFlatFilterItem"][];
+            };
+        })[];
+        /**
+         * @description Control which fields aggregate stats data will be generated for. This includes, min value, max value, average value, and document counts per interval within the dataset.
+         *
+         *     Aggregate data will appear in the "aggregateStats" property of the response body.
+         *
+         *     Each list item can be:
+         *
+         *      a string stating which field to aggregate stats on
+         *
+         *     An object containing "field" to pick a field, and "interval" to control the range of each bucket when counting documents:
+         *
+         *     For example, if we had products {"price":50},{"price:"150"},{price:"180"},{"field":"price","interval":100}  would split results into 2 buckets.
+         *
+         *     Default: []
+         *     Example: ["postcode",{"field":"price","interval":10}]
+         */
+        fieldsToAggregateStats: (string | {
+            /** @description Field to return stats for in aggregateStats. */
+            field?: string;
+            /** @description Interval gap when building a histogram. An interval of 2 will count documents in range 0-2,2-4,4-6... */
+            interval?: number;
+            /** @description Controls which field the aggregate output will be placed into. */
+            outputField?: string;
+        })[];
+        simpleSearchFilterItem: {
+            /** @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?: {
                     /**
@@ -11729,6 +12096,42 @@ export interface components {
         CreateSavedFilterOutput: {
             id: string;
         };
+        DeleteComponentInput: unknown;
+        DeleteComponentOutput: unknown;
+        ListComponentsInput: {
+            [key: string]: unknown;
+        };
+        ListComponentsOutput: {
+            results: {
+                _id?: string;
+                configuration?: {
+                    [key: string]: unknown;
+                };
+            }[];
+        };
+        UpdateComponentInput: {
+            _id?: string;
+            configuration?: {
+                [key: string]: unknown;
+            };
+        };
+        UpdateComponentOutput: unknown;
+        GetComponentInput: unknown;
+        GetComponentOutput: {
+            _id?: string;
+            configuration?: {
+                [key: string]: unknown;
+            };
+        };
+        CreateComponentInput: {
+            _id?: string;
+            configuration?: {
+                [key: string]: unknown;
+            };
+        };
+        CreateComponentOutput: {
+            id: string;
+        };
     };
 }
 export interface operations {
@@ -12045,12 +12448,281 @@ export interface operations {
     ListDeployables: {
         parameters: {
             query: {
+                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. */
+                        key?: string;
+                        /** @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. */
+                        key?: string;
+                        /** @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. */
+                        key?: string;
+                        /** @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. */
+                            key?: 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. */
+                        key?: string;
+                        /** @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?: (definitions["simpleSearchAndFlatFilterItem"][] | definitions["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?: definitions["simpleSearchAndFlatFilterItem"][] | definitions["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: definitions["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;
+                }>)[];
+                /** Fields to include in the search results, empty array/list means all fields. */
+                select_fields?: string[];
+                /** Size of each page of results. */
+                page_size?: number;
+                /** Size of each page of results. */
+                page?: number;
+                /** 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";
+                })[];
+                /** Include vectors in the search results. */
+                include_vector?: boolean;
+                /** (NOT IMPLEMENTED - not functional) If true, retrieves documents randomly. */
+                is_random?: boolean;
+                /** (NOT IMPLEMENTED - not functional)Random Seed for retrieving random documents. */
+                random_state?: number;
+                /** Retrieve items after these sort values in the sort order. */
+                after_id?: unknown[];
                 /** Unique name of the dataset */
                 dataset_id?: string;
-                /** Page of the results */
-                page?: number;
-                /** Size of each page of results */
-                page_size?: number;
             };
         };
         responses: {
@@ -15937,15 +16609,358 @@ export interface operations {
             /** successful operation */
             200: {
                 content: {
-                    "application/json": components["schemas"]["PaginateDocumentsOutput"];
+                    "application/json": components["schemas"]["PaginateDocumentsOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PaginateDocumentsInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read",
+     *       "datasets:write"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    CreateDatasetSummary: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["CreateDatasetSummaryOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateDatasetSummaryInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    ListDatasetSummaryHistory: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+            query: {
+                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. */
+                        key?: string;
+                        /** @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. */
+                        key?: string;
+                        /** @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. */
+                        key?: string;
+                        /** @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. */
+                            key?: 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. */
+                        key?: string;
+                        /** @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?: (definitions["simpleSearchAndFlatFilterItem"][] | definitions["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?: definitions["simpleSearchAndFlatFilterItem"][] | definitions["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: definitions["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;
+                }>)[];
+                /** Fields to include in the search results, empty array/list means all fields. */
+                select_fields?: string[];
+                /** Size of each page of results. */
+                page_size?: number;
+                /** Size of each page of results. */
+                page?: number;
+                /** 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";
+                })[];
+                /** Include vectors in the search results. */
+                include_vector?: boolean;
+                /** (NOT IMPLEMENTED - not functional) If true, retrieves documents randomly. */
+                is_random?: boolean;
+                /** (NOT IMPLEMENTED - not functional)Random Seed for retrieving random documents. */
+                random_state?: number;
+                /** Retrieve items after these sort values in the sort order. */
+                after_id?: unknown[];
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["ListDatasetSummaryHistoryOutput"];
                 };
             };
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["PaginateDocumentsInput"];
-            };
-        };
     };
     /**
      * Retrieve documents by their IDs ("_id" field). This will retrieve the documents faster than a filter applied on the "_id" field. For single id lookup version of this request use /datasets/{dataset_id}/documents/get.
@@ -16977,6 +17992,116 @@ export interface operations {
             };
         };
     };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    DeleteComponent: {
+        parameters: {
+            path: {
+                /** ID of component */
+                component_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["DeleteComponentOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DeleteComponentInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    ListComponents: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["ListComponentsOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ListComponentsInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    UpdateComponent: {
+        parameters: {
+            path: {
+                /** ID of component */
+                component_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["UpdateComponentOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateComponentInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    GetComponent: {
+        parameters: {
+            path: {
+                /** ID of component */
+                component_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["GetComponentOutput"];
+                };
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    CreateComponent: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["CreateComponentOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateComponentInput"];
+            };
+        };
+    };
 }
 export interface external {
 }