@relevanceai/sdk 1.133.0 → 1.134.0

package/dist-cjs/generated/DiscoveryApi.js

@@ -414,6 +414,14 @@ class DiscoveryApiClient extends BaseClient_1._GenericClient {
             options
         });
     }
+    async CreateHierarchicalClusters(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'post',
+            path: '/datasets/{dataset_id}/cluster/hierarchical/create',
+            options
+        });
+    }
     async DeleteClusterSummaries(input, options) {
         return this.SendRequest({
             input,
@@ -1326,5 +1334,45 @@ class DiscoveryApiClient extends BaseClient_1._GenericClient {
             options
         });
     }
+    async ListTaxonomys(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'post',
+            path: '/taxonomys/list',
+            options
+        });
+    }
+    async UpdateTaxonomy(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'post',
+            path: '/taxonomys/{taxonomy_id}/update',
+            options
+        });
+    }
+    async DeleteTaxonomy(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'post',
+            path: '/taxonomys/{taxonomy_id}/delete',
+            options
+        });
+    }
+    async GetTaxonomy(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'get',
+            path: '/taxonomys/{taxonomy_id}/get',
+            options
+        });
+    }
+    async CreateTaxonomy(input, options) {
+        return this.SendRequest({
+            input,
+            method: 'post',
+            path: '/taxonomys/create',
+            options
+        });
+    }
 }
 exports.DiscoveryApiClient = DiscoveryApiClient;

package/dist-es/generated/DiscoveryApi.js

@@ -678,6 +678,18 @@ var DiscoveryApiClient = /** @class */ (function (_super) {
             });
         });
     };
+    DiscoveryApiClient.prototype.CreateHierarchicalClusters = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'post',
+                        path: '/datasets/{dataset_id}/cluster/hierarchical/create',
+                        options: options
+                    })];
+            });
+        });
+    };
     DiscoveryApiClient.prototype.DeleteClusterSummaries = function (input, options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -2046,6 +2058,66 @@ var DiscoveryApiClient = /** @class */ (function (_super) {
             });
         });
     };
+    DiscoveryApiClient.prototype.ListTaxonomys = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'post',
+                        path: '/taxonomys/list',
+                        options: options
+                    })];
+            });
+        });
+    };
+    DiscoveryApiClient.prototype.UpdateTaxonomy = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'post',
+                        path: '/taxonomys/{taxonomy_id}/update',
+                        options: options
+                    })];
+            });
+        });
+    };
+    DiscoveryApiClient.prototype.DeleteTaxonomy = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'post',
+                        path: '/taxonomys/{taxonomy_id}/delete',
+                        options: options
+                    })];
+            });
+        });
+    };
+    DiscoveryApiClient.prototype.GetTaxonomy = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'get',
+                        path: '/taxonomys/{taxonomy_id}/get',
+                        options: options
+                    })];
+            });
+        });
+    };
+    DiscoveryApiClient.prototype.CreateTaxonomy = function (input, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.SendRequest({
+                        input: input,
+                        method: 'post',
+                        path: '/taxonomys/create',
+                        options: options
+                    })];
+            });
+        });
+    };
     return DiscoveryApiClient;
 }(_GenericClient));
 export { DiscoveryApiClient };

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

@@ -102,6 +102,8 @@ export declare type CreateClusterLabelsInput = operations['CreateClusterLabels']
 export declare type CreateClusterLabelsOutput = operations['CreateClusterLabels']['responses']['200']['content']['application/json'];
 export declare type ListClusterSummariesInput = operations['ListClusterSummaries']['requestBody']['content']['application/json'];
 export declare type ListClusterSummariesOutput = operations['ListClusterSummaries']['responses']['200']['content']['application/json'];
+export declare type CreateHierarchicalClustersInput = operations['CreateHierarchicalClusters']['requestBody']['content']['application/json'];
+export declare type CreateHierarchicalClustersOutput = operations['CreateHierarchicalClusters']['responses']['200']['content']['application/json'];
 export declare type DeleteClusterSummariesInput = operations['DeleteClusterSummaries']['requestBody']['content']['application/json'];
 export declare type DeleteClusterSummariesOutput = operations['DeleteClusterSummaries']['responses']['200']['content']['application/json'];
 export declare type CreateOrganizationInput = operations['CreateOrganization']['requestBody']['content']['application/json'];
@@ -330,6 +332,16 @@ export declare type GetKeyphraseInput = {};
 export declare type GetKeyphraseOutput = operations['GetKeyphrase']['responses']['200']['content']['application/json'];
 export declare type BulkUpdateKeyphrasesInput = operations['BulkUpdateKeyphrases']['requestBody']['content']['application/json'];
 export declare type BulkUpdateKeyphrasesOutput = operations['BulkUpdateKeyphrases']['responses']['200']['content']['application/json'];
+export declare type ListTaxonomysInput = operations['ListTaxonomys']['requestBody']['content']['application/json'];
+export declare type ListTaxonomysOutput = operations['ListTaxonomys']['responses']['200']['content']['application/json'];
+export declare type UpdateTaxonomyInput = operations['UpdateTaxonomy']['requestBody']['content']['application/json'];
+export declare type UpdateTaxonomyOutput = operations['UpdateTaxonomy']['responses']['200']['content']['application/json'];
+export declare type DeleteTaxonomyInput = operations['DeleteTaxonomy']['requestBody']['content']['application/json'];
+export declare type DeleteTaxonomyOutput = operations['DeleteTaxonomy']['responses']['200']['content']['application/json'];
+export declare type GetTaxonomyInput = {};
+export declare type GetTaxonomyOutput = operations['GetTaxonomy']['responses']['200']['content']['application/json'];
+export declare type CreateTaxonomyInput = operations['CreateTaxonomy']['requestBody']['content']['application/json'];
+export declare type CreateTaxonomyOutput = operations['CreateTaxonomy']['responses']['200']['content']['application/json'];
 export declare class DiscoveryApiClient extends _GenericClient {
     constructor(config: _ClientInput);
     CreateDeployable(input: CommandInput<CreateDeployableInput>, options?: _GenericMethodOptions): Promise<CommandOutput<CreateDeployableOutput>>;
@@ -383,6 +395,7 @@ export declare class DiscoveryApiClient extends _GenericClient {
     CreateClusterSummaries(input: CommandInput<CreateClusterSummariesInput>, options?: _GenericMethodOptions): Promise<CommandOutput<CreateClusterSummariesOutput>>;
     CreateClusterLabels(input: CommandInput<CreateClusterLabelsInput>, options?: _GenericMethodOptions): Promise<CommandOutput<CreateClusterLabelsOutput>>;
     ListClusterSummaries(input: CommandInput<ListClusterSummariesInput>, options?: _GenericMethodOptions): Promise<CommandOutput<ListClusterSummariesOutput>>;
+    CreateHierarchicalClusters(input: CommandInput<CreateHierarchicalClustersInput>, options?: _GenericMethodOptions): Promise<CommandOutput<CreateHierarchicalClustersOutput>>;
     DeleteClusterSummaries(input: CommandInput<DeleteClusterSummariesInput>, options?: _GenericMethodOptions): Promise<CommandOutput<DeleteClusterSummariesOutput>>;
     CreateOrganization(input: CommandInput<CreateOrganizationInput>, options?: _GenericMethodOptions): Promise<CommandOutput<CreateOrganizationOutput>>;
     UpdateOrganization(input: CommandInput<UpdateOrganizationInput>, options?: _GenericMethodOptions): Promise<CommandOutput<UpdateOrganizationOutput>>;
@@ -497,4 +510,9 @@ export declare class DiscoveryApiClient extends _GenericClient {
     DeleteKeyphrase(input: CommandInput<DeleteKeyphraseInput>, options?: _GenericMethodOptions): Promise<CommandOutput<DeleteKeyphraseOutput>>;
     GetKeyphrase(input: CommandInput<GetKeyphraseInput>, options?: _GenericMethodOptions): Promise<CommandOutput<GetKeyphraseOutput>>;
     BulkUpdateKeyphrases(input: CommandInput<BulkUpdateKeyphrasesInput>, options?: _GenericMethodOptions): Promise<CommandOutput<BulkUpdateKeyphrasesOutput>>;
+    ListTaxonomys(input: CommandInput<ListTaxonomysInput>, options?: _GenericMethodOptions): Promise<CommandOutput<ListTaxonomysOutput>>;
+    UpdateTaxonomy(input: CommandInput<UpdateTaxonomyInput>, options?: _GenericMethodOptions): Promise<CommandOutput<UpdateTaxonomyOutput>>;
+    DeleteTaxonomy(input: CommandInput<DeleteTaxonomyInput>, options?: _GenericMethodOptions): Promise<CommandOutput<DeleteTaxonomyOutput>>;
+    GetTaxonomy(input: CommandInput<GetTaxonomyInput>, options?: _GenericMethodOptions): Promise<CommandOutput<GetTaxonomyOutput>>;
+    CreateTaxonomy(input: CommandInput<CreateTaxonomyInput>, options?: _GenericMethodOptions): Promise<CommandOutput<CreateTaxonomyOutput>>;
 }

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

@@ -902,6 +902,27 @@ export interface paths {
          */
         post: operations["ListClusterSummaries"];
     };
+    "/datasets/{dataset_id}/cluster/hierarchical/create": {
+        /**
+         * Endpoint for creating Hierarchical Clusters from a given dataset on top of existing clusters.
+         *
+         * ### Required permissions
+         * > [
+         *   {
+         *     "actions": [
+         *       "datasets:read",
+         *       "datasets:write"
+         *     ],
+         *     "datasets": [
+         *       {
+         *         "params": "dataset_id"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        post: operations["CreateHierarchicalClusters"];
+    };
     "/datasets/{dataset_id}/cluster/centroids/summaries/bulk_delete": {
         /**
          * ### Required permissions
@@ -2654,6 +2675,41 @@ export interface paths {
          */
         post: operations["BulkUpdateKeyphrases"];
     };
+    "/taxonomys/list": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["ListTaxonomys"];
+    };
+    "/taxonomys/{taxonomy_id}/update": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["UpdateTaxonomy"];
+    };
+    "/taxonomys/{taxonomy_id}/delete": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["DeleteTaxonomy"];
+    };
+    "/taxonomys/{taxonomy_id}/get": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        get: operations["GetTaxonomy"];
+    };
+    "/taxonomys/create": {
+        /**
+         * ### Required permissions
+         * > []
+         */
+        post: operations["CreateTaxonomy"];
+    };
 }
 export interface components {
     schemas: {
@@ -6403,6 +6459,19 @@ export interface components {
                 };
             };
         };
+        CreateHierarchicalClustersInput: {
+            /** @description The vector fields that these centroids are associated with. */
+            vector_fields?: string[];
+            centroid_vector_fields?: string[];
+            /** @description Alias is used to name a cluster. */
+            alias?: string;
+            dataset_id?: string;
+            /** @default 10 */
+            n_clusters?: number;
+        };
+        CreateHierarchicalClustersOutput: {
+            alias: string;
+        };
         DeleteClusterSummariesInput: {
             /** @description The vector fields that these centroids are associated with. */
             vector_fields?: string[];
@@ -7624,9 +7693,9 @@ export interface components {
                                 [key: string]: unknown;
                             };
                             workflow_id: string;
-                            dataset_id: string;
                         };
                         depends_on?: string[];
+                        if?: string;
                     };
                 };
             };
@@ -7670,9 +7739,9 @@ export interface components {
                                     [key: string]: unknown;
                                 };
                                 workflow_id: string;
-                                dataset_id: string;
                             };
                             depends_on?: string[];
+                            if?: string;
                         };
                     };
                 };
@@ -7729,9 +7798,9 @@ export interface components {
                                 [key: string]: unknown;
                             };
                             workflow_id: string;
-                            dataset_id: string;
                         };
                         depends_on?: string[];
+                        if?: string;
                     };
                 };
             };
@@ -7822,9 +7891,9 @@ export interface components {
                                 [key: string]: unknown;
                             };
                             workflow_id: string;
-                            dataset_id: string;
                         };
                         depends_on?: string[];
+                        if?: string;
                     };
                 };
             };
@@ -9212,6 +9281,14 @@ export interface components {
             updates: {
                 [key: string]: unknown;
             };
+            /** @description Updates to apply conditionally based on a fields value. For example, if a field category exists, to add categoryUppercase use conditional_updates:[{field:"category",output_field:"categoryUppercase",condition_map:{"nonfiction":"NONFICTION"}}] */
+            conditional_updates?: {
+                field: string;
+                output_field: string;
+                condition_map: {
+                    [key: string]: unknown;
+                };
+            }[];
         };
         UpdateWhereOutput: {
             /** @description Completion status. */
@@ -13282,12 +13359,22 @@ export interface components {
             results: {
                 _id?: string;
                 keyphrase?: string;
+                ancestors?: string[];
+                parents?: string[];
+                metadata?: {
+                    [key: string]: unknown;
+                };
                 score?: number;
             }[];
         };
         UpdateKeyphraseInput: {
             _id?: string;
             keyphrase?: string;
+            ancestors?: string[];
+            parents?: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
             score?: number;
         };
         UpdateKeyphraseOutput: unknown;
@@ -13297,16 +13384,79 @@ export interface components {
         GetKeyphraseOutput: {
             _id?: string;
             keyphrase?: string;
+            ancestors?: string[];
+            parents?: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
             score?: number;
         };
         BulkUpdateKeyphrasesInput: {
             updates?: {
                 _id?: string;
                 keyphrase?: string;
+                ancestors?: string[];
+                parents?: string[];
+                metadata?: {
+                    [key: string]: unknown;
+                };
                 score?: number;
             }[];
         };
         BulkUpdateKeyphrasesOutput: unknown;
+        ListTaxonomysInput: {
+            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";
+            })[];
+        };
+        ListTaxonomysOutput: {
+            results: {
+                _id?: string;
+                name?: string;
+                taxonomy?: string[];
+                description?: string;
+                metadata?: {
+                    [key: string]: unknown;
+                };
+            }[];
+        };
+        UpdateTaxonomyInput: {
+            _id?: string;
+            name?: string;
+            taxonomy?: string[];
+            description?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        UpdateTaxonomyOutput: unknown;
+        DeleteTaxonomyInput: unknown;
+        DeleteTaxonomyOutput: unknown;
+        GetTaxonomyInput: unknown;
+        GetTaxonomyOutput: {
+            _id?: string;
+            name?: string;
+            taxonomy?: string[];
+            description?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        CreateTaxonomyInput: {
+            _id?: string;
+            name?: string;
+            taxonomy?: string[];
+            description?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        CreateTaxonomyOutput: {
+            id: string;
+        };
     };
 }
 export interface operations {
@@ -15286,6 +15436,45 @@ export interface operations {
             };
         };
     };
+    /**
+     * Endpoint for creating Hierarchical Clusters from a given dataset on top of existing clusters.
+     *
+     * ### Required permissions
+     * > [
+     *   {
+     *     "actions": [
+     *       "datasets:read",
+     *       "datasets:write"
+     *     ],
+     *     "datasets": [
+     *       {
+     *         "params": "dataset_id"
+     *       }
+     *     ]
+     *   }
+     * ]
+     */
+    CreateHierarchicalClusters: {
+        parameters: {
+            path: {
+                /** ID of dataset */
+                dataset_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["CreateHierarchicalClustersOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateHierarchicalClustersInput"];
+            };
+        };
+    };
     /**
      * ### Required permissions
      * > [
@@ -19696,6 +19885,116 @@ export interface operations {
             };
         };
     };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    ListTaxonomys: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["ListTaxonomysOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ListTaxonomysInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    UpdateTaxonomy: {
+        parameters: {
+            path: {
+                /** ID of taxonomy */
+                taxonomy_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["UpdateTaxonomyOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateTaxonomyInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    DeleteTaxonomy: {
+        parameters: {
+            path: {
+                /** ID of taxonomy */
+                taxonomy_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["DeleteTaxonomyOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DeleteTaxonomyInput"];
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    GetTaxonomy: {
+        parameters: {
+            path: {
+                /** ID of taxonomy */
+                taxonomy_id: string;
+            };
+        };
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["GetTaxonomyOutput"];
+                };
+            };
+        };
+    };
+    /**
+     * ### Required permissions
+     * > []
+     */
+    CreateTaxonomy: {
+        parameters: {};
+        responses: {
+            /** successful operation */
+            200: {
+                content: {
+                    "application/json": components["schemas"]["CreateTaxonomyOutput"];
+                };
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateTaxonomyInput"];
+            };
+        };
+    };
 }
 export interface external {
 }

package/package.json

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