@aviaryhq/cloudglue-js 0.4.11 → 0.4.13

package/dist/src/client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudGlue = exports.CloudGlueError = void 0;
+exports.CloudGlue = void 0;
 const Files_1 = require("../generated/Files");
 const Collections_1 = require("../generated/Collections");
 const Chat_1 = require("../generated/Chat");
@@ -14,644 +14,39 @@ const Webhooks_1 = require("../generated/Webhooks");
 const Frames_1 = require("../generated/Frames");
 const Face_Detection_1 = require("../generated/Face_Detection");
 const Face_Match_1 = require("../generated/Face_Match");
-class CloudGlueError extends Error {
-    constructor(message, statusCode, data, headers, responseData) {
-        super(message);
-        this.statusCode = statusCode;
-        this.data = data;
-        this.headers = headers;
-        this.responseData = responseData;
-        this.name = "CloudGlueError";
-    }
-}
-exports.CloudGlueError = CloudGlueError;
-// Enhanced API client classes
-class EnhancedFilesApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async listFiles(params = {}) {
-        const { filter, ...otherParams } = params;
-        // Convert filter object to JSON string if provided
-        const queries = { ...otherParams };
-        if (filter) {
-            try {
-                queries.filter = JSON.stringify(filter);
-            }
-            catch (error) {
-                throw new CloudGlueError(`Failed to serialize filter object: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        }
-        return this.api.listFiles({ queries });
-    }
-    async uploadFile(params) {
-        // File uploads require special handling for multipart/form-data that the generated Zodios client doesn't handle automatically.
-        // We need to:
-        // 1. Create a FormData object and append the file with the correct field name
-        // 2. JSON stringify the metadata if present
-        // 3. Set the correct Content-Type header
-        // This is why we use axios directly instead of the generated client method.
-        const formData = new FormData();
-        formData.append("file", params.file);
-        // Add metadata if provided
-        if (params.metadata) {
-            try {
-                formData.append("metadata", JSON.stringify(params.metadata));
-            }
-            catch (error) {
-                throw new CloudGlueError(`Failed to serialize metadata object: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        }
-        if (params.enable_segment_thumbnails !== undefined) {
-            formData.append("enable_segment_thumbnails", params.enable_segment_thumbnails.toString());
-        }
-        // Use axios directly to bypass Zodios validation
-        return this.api.axios({
-            method: "post",
-            url: "/files",
-            data: formData,
-            headers: {
-                "Content-Type": "multipart/form-data",
-            },
-        });
-    }
-    async getFile(fileId) {
-        return this.api.getFile({ params: { file_id: fileId } });
-    }
-    async deleteFile(fileId) {
-        return this.api.deleteFile(undefined, {
-            params: { file_id: fileId },
-        });
-    }
-    async updateFile(fileId, params) {
-        return this.api.updateFile({ ...params, filename: params.filename ?? undefined }, { params: { file_id: fileId } });
-    }
-    async listFileSegmentations(fileId, params = {}) {
-        return this.api.listFileSegmentations({
-            params: { file_id: fileId },
-            queries: params,
-        });
-    }
-    /**
-     * Get thumbnails for a file. If a segmentationId is provided, the thumbnails will be for a specific segmentation.
-     * @param fileId - The ID of the file
-     * @param params - Optional parameters
-     * @returns The thumbnails for the file
-     */
-    async getFileThumbnails(fileId, params = {}) {
-        return this.api.getThumbnails({
-            params: { file_id: fileId },
-            queries: {
-                ...params,
-                is_default: params.isDefault ?? false,
-                segmentation_id: params.segmentationId ?? undefined,
-            },
-        });
-    }
-    async createFileSegmentation(fileId, params) {
-        return this.api.createFileSegmentation(params, {
-            params: { file_id: fileId },
-            body: params,
-        });
-    }
-    async createFileFrameExtraction(fileId, params) {
-        return this.api.createFileFrameExtraction(params, {
-            params: { file_id: fileId }
-        });
-    }
-    /**
-     * Waits for a file to finish processing by polling the getFile endpoint until the file
-     * reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
-     *
-     * @param fileId - The ID of the file to wait for
-     * @param options - Optional configuration for polling behavior
-     * @returns The final file object
-     * @throws {CloudGlueError} If the file fails to process or maxAttempts is reached
-     */
-    async waitForReady(fileId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36 } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const file = await this.getFile(fileId);
-            // If we've reached a terminal state, return the file
-            if (["completed", "failed", "not_applicable"].includes(file.status)) {
-                if (file.status === "failed") {
-                    throw new CloudGlueError(`File processing failed: ${fileId}`);
-                }
-                return file;
-            }
-            // Wait for the polling interval before trying again
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Timeout waiting for file ${fileId} to process after ${maxAttempts} attempts`);
-    }
-}
-class EnhancedCollectionsApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async listCollections(params = {}) {
-        return this.api.listCollections({ queries: params });
-    }
-    async createCollection(params) {
-        return this.api.createCollection(params);
-    }
-    async getCollection(collectionId) {
-        return this.api.getCollection({
-            params: { collection_id: collectionId },
-        });
-    }
-    async deleteCollection(collectionId) {
-        return this.api.deleteCollection(undefined, { params: { collection_id: collectionId } });
-    }
-    async updateCollection(collectionId, params) {
-        return this.api.updateCollection(params, { params: { collection_id: collectionId } });
-    }
-    async addVideoByUrl({ collectionId, url, params }) {
-        return this.api.addVideo({ url, ...params }, { params: { collection_id: collectionId, ...params } });
-    }
-    async addVideo(collectionId, fileId, params = {}) {
-        return this.api.addVideo({ file_id: fileId, ...params }, { params: { collection_id: collectionId, ...params } });
-    }
-    async listVideos(collectionId, params = {}) {
-        const { filter, ...otherParams } = params;
-        // Convert filter object to JSON string if provided
-        const queries = { ...otherParams };
-        if (filter) {
-            try {
-                queries.filter = JSON.stringify(filter);
-            }
-            catch (error) {
-                throw new CloudGlueError(`Failed to serialize filter object: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        }
-        return this.api.listVideos({
-            params: { collection_id: collectionId },
-            queries,
-        });
-    }
-    async getVideo(collectionId, fileId) {
-        return this.api.getVideo({
-            params: { collection_id: collectionId, file_id: fileId },
-        });
-    }
-    async deleteVideo(collectionId, fileId) {
-        return this.api.deleteVideo(undefined, { params: { collection_id: collectionId, file_id: fileId } });
-    }
-    async getEntities(collectionId, fileId, params = {}) {
-        return this.api.getEntities({
-            params: { collection_id: collectionId, file_id: fileId },
-            queries: params
-        });
-    }
-    async getTranscripts(collectionId, fileId, options = {}) {
-        return this.api.getTranscripts({
-            params: { collection_id: collectionId, file_id: fileId },
-            queries: { ...options },
-        });
-    }
-    async listEntities(collectionId, params = {}) {
-        return this.api.listCollectionEntities({
-            params: { collection_id: collectionId },
-            queries: params,
-        });
-    }
-    async listRichTranscripts(collectionId, params = {}) {
-        return this.api.listCollectionRichTranscripts({
-            params: { collection_id: collectionId },
-            queries: params,
-        });
-    }
-    async getMediaDescriptions(collectionId, fileId, options = {}) {
-        return this.api.getMediaDescriptions({
-            params: { collection_id: collectionId, file_id: fileId },
-            queries: { ...options },
-        });
-    }
-    async getFaceDetections(collectionId, fileId, params = {}) {
-        return this.api.getFaceDetections({
-            params: { collection_id: collectionId, file_id: fileId },
-            queries: params
-        });
-    }
-    async listMediaDescriptions(collectionId, params = {}) {
-        return this.api.listCollectionMediaDescriptions({
-            params: { collection_id: collectionId },
-            queries: params,
-        });
-    }
-    /**
-     * Waits for a video in a collection to be ready by polling the getVideo endpoint until
-     * the video reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
-     *
-     * @param collectionId - The ID of the collection containing the video
-     * @param fileId - The ID of the video file to wait for
-     * @param options - Optional configuration for polling behavior
-     * @returns The final collection file object
-     * @throws {CloudGlueError} If the video fails to process or maxAttempts is reached
-     */
-    async waitForReady(collectionId, fileId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36 } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const video = await this.getVideo(collectionId, fileId);
-            // If we've reached a terminal state, return the video
-            if (["completed", "failed", "not_applicable"].includes(video.status)) {
-                if (video.status === "failed") {
-                    throw new CloudGlueError(`Video processing failed: ${fileId} in collection ${collectionId}`);
-                }
-                return video;
-            }
-            // Wait for the polling interval before trying again
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Timeout waiting for video ${fileId} in collection ${collectionId} to process after ${maxAttempts} attempts`);
-    }
-}
-class EnhancedChatApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async createCompletion(params) {
-        return this.api.createCompletion({
-            model: params.model || "nimbus-001",
-            ...params,
-        });
-    }
-}
-/**
- * @deprecated
- */
-class EnhancedTranscribeApi {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * @deprecated use createDescribe instead
-     */
-    async createTranscribe(url, options = {}) {
-        return this.api.createTranscribe({
-            url,
-            ...options,
-        });
-    }
-    /**
-     * @deprecated use getDescribe instead
-     */
-    async getTranscribe(jobId, options = {}) {
-        return this.api.getTranscribe({
-            params: { job_id: jobId },
-            queries: { response_format: options.response_format },
-        });
-    }
-    /**
-     * @deprecated use listDescribes instead
-     */
-    async listTranscribes(params = {}) {
-        return this.api.listTranscribes({ queries: params });
-    }
-    /**
-     * Waits for a transcription job to be ready by polling the getTranscribe endpoint until
-     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
-     *
-     * @param jobId - The ID of the transcription job to wait for
-     * @param options - Optional configuration for polling behavior and response format
-     * @returns The final transcription job object
-     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
-     * @deprecated
-     */
-    async waitForReady(jobId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36, response_format, } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getTranscribe(jobId, { response_format });
-            // If we've reached a terminal state, return the job
-            if (["completed", "failed", "not_applicable"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Transcription job failed: ${jobId}`);
-                }
-                return job;
-            }
-            // Wait for the polling interval before trying again
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Timeout waiting for transcription job ${jobId} to process after ${maxAttempts} attempts`);
-    }
-}
-class EnhancedExtractApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async createExtract(url, options) {
-        return this.api.createExtract({
-            url,
-            ...options,
-        });
-    }
-    async getExtract(jobId, params = {}) {
-        return this.api.getExtract({
-            params: { job_id: jobId },
-            queries: params
-        });
-    }
-    async listExtracts(params = {}) {
-        return this.api.listExtracts({ queries: params });
-    }
-    async deleteExtract(jobId) {
-        return this.api.deleteExtract(undefined, { params: { job_id: jobId } });
-    }
-    /**
-     * Waits for an extraction job to be ready by polling the getExtract endpoint until
-     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
-     *
-     * @param jobId - The ID of the extraction job to wait for
-     * @param options - Optional configuration for polling behavior
-     * @returns The final extraction job object
-     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
-     */
-    async waitForReady(jobId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36 } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getExtract(jobId);
-            // If we've reached a terminal state, return the job
-            if (["completed", "failed", "not_applicable"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Extraction job failed: ${jobId}`);
-                }
-                return job;
-            }
-            // Wait for the polling interval before trying again
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Timeout waiting for extraction job ${jobId} to process after ${maxAttempts} attempts`);
-    }
-}
-class EnhancedSegmentationsApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async getSegmentation(segmentationId, params = {}) {
-        return this.api.getSegmentation({
-            params: { segmentation_id: segmentationId },
-            queries: params,
-        });
-    }
-    async deleteSegmentation(segmentationId) {
-        return this.api.deleteSegmentation(undefined, {
-            params: { segmentation_id: segmentationId },
-        });
-    }
-    /**
-     * Get thumbnails for a specific segmentation
-     * @param segmentationId - The ID of the segmentation
-     * @param params - Optional parameters
-     * @returns The thumbnails for the segmentation
-     */
-    async getSegmentationThumbnails(segmentationId, params = {}) {
-        return this.api.getSegmentationThumbnails({
-            params: { segmentation_id: segmentationId },
-            queries: {
-                ...params,
-                segment_ids: params.segment_ids?.join(","),
-            },
-        });
-    }
-}
-class EnhancedSearchApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async searchContent(params) {
-        return this.api.searchContent(params);
-    }
-}
-class EnhancedDescribeApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async createDescribe(url, options = {}) {
-        return this.api.createDescribe({
-            url,
-            ...options,
-        });
-    }
-    async getDescribe(jobId, options = {
-        response_format: "json",
-    }) {
-        return this.api.getDescribe({
-            params: { job_id: jobId },
-            queries: { ...options },
-        });
-    }
-    async listDescribes(params = {}) {
-        return this.api.listDescribes({ queries: params });
-    }
-    async deleteDescribe(jobId) {
-        return this.api.deleteDescribe(undefined, { params: { job_id: jobId } });
-    }
-    /**
-     * Waits for a description job to be ready by polling the getDescribe endpoint until
-     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
-     *
-     * @param jobId - The ID of the description job to wait for
-     * @param options - Optional configuration for polling behavior and response format
-     * @returns The final description job object
-     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
-     */
-    async waitForReady(jobId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36, response_format, } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getDescribe(jobId, { response_format });
-            // If we've reached a terminal state, return the job
-            if (["completed", "failed", "not_applicable"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Description job failed: ${jobId}`);
-                }
-                return job;
-            }
-            // Wait for the polling interval before trying again
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Timeout waiting for description job ${jobId} to process after ${maxAttempts} attempts`);
-    }
-}
-class EnhancedSegmentsApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async listSegmentJobs(data) {
-        return this.api.listSegments({ queries: data });
-    }
-    async getSegmentJob(jobId) {
-        return this.api.getSegments({ params: { job_id: jobId } });
-    }
-    async createSegmentJob(params) {
-        return this.api.createSegments(params);
-    }
-    async deleteSegmentJob(jobId) {
-        return this.api.deleteSegments(undefined, { params: { job_id: jobId } });
-    }
-    async waitForReady(jobId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36, } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getSegmentJob(jobId);
-            // If we've reached a terminal state, return the job
-            if (["completed", "failed", "not_applicable"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Segment job failed: ${jobId}`);
-                }
-                return job;
-            }
-            // Wait for the polling interval before trying again
-            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Timeout waiting for segment job ${jobId} to process after ${maxAttempts} attempts`);
-    }
-}
-class EnhancedWebhooksApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async listWebhooks(params = {}) {
-        return this.api.listWebhooks({ queries: params });
-    }
-    async getWebhook(webhookId) {
-        return this.api.getWebhookById({ params: { webhook_id: webhookId } });
-    }
-    async createWebhook(params) {
-        return this.api.createWebhook(params);
-    }
-    async updateWebhook(webhookId, params) {
-        return this.api.updateWebhook(params, { params: { webhook_id: webhookId, } });
-    }
-    async deleteWebhook(webhookId) {
-        return this.api.deleteWebhook(undefined, { params: { webhook_id: webhookId } });
-    }
-}
-class EnhancedFramesApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async getFrameExtraction(frameExtractionId, params = {}) {
-        return this.api.getFrameExtraction({
-            params: { frame_extraction_id: frameExtractionId },
-            queries: params
-        });
-    }
-    async deleteFrameExtraction(frameExtractionId) {
-        return this.api.deleteFrameExtraction(undefined, { params: { frame_extraction_id: frameExtractionId } });
-    }
-    async waitForReady(frameExtractionId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36 } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getFrameExtraction(frameExtractionId);
-            if (["completed", "failed"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Frame extraction job failed: ${frameExtractionId}`);
-                }
-                return job;
-            }
-            await new Promise(resolve => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Frame extraction job did not complete within ${maxAttempts * pollingInterval / 1000} seconds: ${frameExtractionId}`);
-    }
-}
-class EnhancedFaceDetectionApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async createFaceDetection(params) {
-        return this.api.createFaceDetection(params);
-    }
-    async getFaceDetection(faceDetectionId, params = {}) {
-        const { limit, offset } = params;
-        return this.api.getFaceDetection({
-            params: { face_detection_id: faceDetectionId },
-            queries: { limit, offset }
-        });
-    }
-    async deleteFaceDetection(faceDetectionId) {
-        return this.api.deleteFaceDetection(undefined, { params: { face_detection_id: faceDetectionId } });
-    }
-    async waitForReady(faceDetectionId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36 } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getFaceDetection(faceDetectionId);
-            if (["completed", "failed"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Face detection job failed: ${faceDetectionId}`);
-                }
-                return job;
-            }
-            await new Promise(resolve => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Face detection job did not complete within ${maxAttempts * pollingInterval / 1000} seconds: ${faceDetectionId}`);
-    }
-}
-class EnhancedFaceMatchApi {
-    constructor(api) {
-        this.api = api;
-    }
-    async createFaceMatch(params) {
-        return this.api.createFaceMatch(params);
-    }
-    async getFaceMatch(faceMatchId, params = {}) {
-        const { limit, offset } = params;
-        return this.api.getFaceMatch({
-            params: { face_match_id: faceMatchId },
-            queries: { limit, offset }
-        });
-    }
-    async deleteFaceMatch(faceMatchId) {
-        return this.api.deleteFaceMatch(undefined, { params: { face_match_id: faceMatchId } });
-    }
-    async waitForReady(faceMatchId, options = {}) {
-        const { pollingInterval = 5000, maxAttempts = 36 } = options;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
-            const job = await this.getFaceMatch(faceMatchId);
-            if (["completed", "failed"].includes(job.status)) {
-                if (job.status === "failed") {
-                    throw new CloudGlueError(`Face match job failed: ${faceMatchId}`);
-                }
-                return job;
-            }
-            await new Promise(resolve => setTimeout(resolve, pollingInterval));
-            attempts++;
-        }
-        throw new CloudGlueError(`Face match job did not complete within ${maxAttempts * pollingInterval / 1000} seconds: ${faceMatchId}`);
-    }
-}
+const Tags_1 = require("../generated/Tags");
+const webhooks_api_1 = require("./api/webhooks.api");
+const tags_api_1 = require("./api/tags.api");
+const error_1 = require("./error");
+const files_api_1 = require("./api/files.api");
+const describe_api_1 = require("./api/describe.api");
+const extract_api_1 = require("./api/extract.api");
+const face_detection_api_1 = require("./api/face-detection.api");
+const face_match_api_1 = require("./api/face-match.api");
+const frame_extraction_api_1 = require("./api/frame-extraction.api");
+const search_api_1 = require("./api/search.api");
+const segmentations_api_1 = require("./api/segmentations.api");
+const segments_api_1 = require("./api/segments.api");
+const transcribe_api_1 = require("./api/transcribe.api");
+const chat_completion_api_1 = require("./api/chat-completion.api");
+const collections_api_1 = require("./api/collections.api");
 /**
  * Main CloudGlue client class that provides access to all API functionality
  * through enhanced, user-friendly interfaces
  */
 class CloudGlue {
     constructor(config = {}) {
-        this.apiKey = config.apiKey || process.env.CLOUDGLUE_API_KEY || "";
-        this.baseUrl = config.baseUrl || "https://api.cloudglue.dev/v1";
+        this.apiKey = config.apiKey || process.env.CLOUDGLUE_API_KEY || '';
+        this.baseUrl = config.baseUrl || 'https://api.cloudglue.dev/v1';
         this.timeout = config.timeout || undefined;
         if (!this.apiKey) {
-            throw new Error("API key is required. Please provide an API key via constructor or CLOUDGLUE_API_KEY environment variable.");
+            throw new Error('API key is required. Please provide an API key via constructor or CLOUDGLUE_API_KEY environment variable.');
         }
         const axiosConfig = {
             headers: {
                 Authorization: `Bearer ${this.apiKey}`,
                 'x-sdk-client': 'cloudglue-js',
-                'x-sdk-version': '0.4.11',
+                'x-sdk-version': '0.4.13',
             },
             baseURL: this.baseUrl,
             timeout: this.timeout,
@@ -676,39 +71,56 @@ class CloudGlue {
         const faceDetectionApi = (0, Face_Detection_1.createApiClient)(this.baseUrl, sharedConfig);
         const faceMatchApi = (0, Face_Match_1.createApiClient)(this.baseUrl, sharedConfig);
         const webhooksApi = (0, Webhooks_1.createApiClient)(this.baseUrl, sharedConfig);
+        const tagsApi = (0, Tags_1.createApiClient)(this.baseUrl, sharedConfig);
         // Configure base URL and axios config for all clients
-        [filesApi, collectionsApi, chatApi, transcribeApi, extractApi, segmentationsApi, searchApi, describeApi, segmentsApi, framesApi, faceDetectionApi, faceMatchApi, webhooksApi].forEach((client) => {
+        [
+            filesApi,
+            collectionsApi,
+            chatApi,
+            transcribeApi,
+            extractApi,
+            segmentationsApi,
+            searchApi,
+            describeApi,
+            segmentsApi,
+            framesApi,
+            faceDetectionApi,
+            faceMatchApi,
+            webhooksApi,
+            tagsApi,
+        ].forEach((client) => {
             Object.assign(client.axios.defaults, axiosConfig);
             client.axios.interceptors.response.use((response) => {
                 return response;
             }, (error) => {
                 if (error.code === 'ECONNABORTED') {
-                    return Promise.reject(new CloudGlueError(error.message, 408, error.config.data, error.response?.headers ?? error.headers, error.response?.data));
+                    return Promise.reject(new error_1.CloudGlueError(error.message, 408, error.config.data, error.response?.headers ?? error.headers, error.response?.data));
                 }
                 else if (error.response) {
                     // The request was made and the server responded with a status code
                     // that falls out of the range of 2xx
                     const data = error.response.data;
-                    return Promise.reject(new CloudGlueError(data.error, error.response.status, error.config.data, error.response.headers, error.response.data));
+                    return Promise.reject(new error_1.CloudGlueError(data.error, error.response.status, error.config.data, error.response.headers, error.response.data));
                 }
                 // Something happened in setting up the request that triggered an Error
-                return Promise.reject(new CloudGlueError(error.message, error.statusCode ?? 500, error.data, error.headers, error.response?.data));
+                return Promise.reject(new error_1.CloudGlueError(error.message, error.statusCode ?? 500, error.data, error.headers, error.response?.data));
             });
         });
         // Create enhanced API clients
-        this.files = new EnhancedFilesApi(filesApi);
-        this.collections = new EnhancedCollectionsApi(collectionsApi);
-        this.chat = new EnhancedChatApi(chatApi);
-        this.transcribe = new EnhancedTranscribeApi(transcribeApi);
-        this.extract = new EnhancedExtractApi(extractApi);
-        this.segmentations = new EnhancedSegmentationsApi(segmentationsApi);
-        this.search = new EnhancedSearchApi(searchApi);
-        this.describe = new EnhancedDescribeApi(describeApi);
-        this.segments = new EnhancedSegmentsApi(segmentsApi);
-        this.frames = new EnhancedFramesApi(framesApi);
-        this.faceDetection = new EnhancedFaceDetectionApi(faceDetectionApi);
-        this.faceMatch = new EnhancedFaceMatchApi(faceMatchApi);
-        this.webhooks = new EnhancedWebhooksApi(webhooksApi);
+        this.files = new files_api_1.EnhancedFilesApi(filesApi);
+        this.collections = new collections_api_1.EnhancedCollectionsApi(collectionsApi);
+        this.chat = new chat_completion_api_1.EnhancedChatApi(chatApi);
+        this.transcribe = new transcribe_api_1.EnhancedTranscribeApi(transcribeApi);
+        this.extract = new extract_api_1.EnhancedExtractApi(extractApi);
+        this.segmentations = new segmentations_api_1.EnhancedSegmentationsApi(segmentationsApi);
+        this.search = new search_api_1.EnhancedSearchApi(searchApi);
+        this.describe = new describe_api_1.EnhancedDescribeApi(describeApi);
+        this.segments = new segments_api_1.EnhancedSegmentsApi(segmentsApi);
+        this.frames = new frame_extraction_api_1.EnhancedFramesApi(framesApi);
+        this.faceDetection = new face_detection_api_1.EnhancedFaceDetectionApi(faceDetectionApi);
+        this.faceMatch = new face_match_api_1.EnhancedFaceMatchApi(faceMatchApi);
+        this.webhooks = new webhooks_api_1.EnhancedWebhooksApi(webhooksApi);
+        this.tags = new tags_api_1.EnhancedTagsApi(tagsApi);
     }
 }
 exports.CloudGlue = CloudGlue;