@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/youtube/tools/subscribe-channel.d.ts

@@ -0,0 +1,5 @@
+export declare const subscribeChannel: import("ai").Tool<{
+    youtubeToken: string;
+    channelId: string;
+}, any>;
+//# sourceMappingURL=subscribe-channel.d.ts.map

package/dist/toolkits/youtube/tools/subscribe-channel.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const subscribeChannel = tool({
+    description: 'Subscribes the authenticated user to a channel by channel ID.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        channelId: z.string().describe("Channel ID to subscribe to (starts with 'UC')"),
+    }),
+    execute: async ({ youtubeToken, channelId }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/subscriptions', {
+                method: 'POST',
+                query: { part: 'snippet' },
+                body: { snippet: { resourceId: { kind: 'youtube#channel', channelId } } },
+            });
+            if (!result.ok)
+                return { error: 'Failed to subscribe to channel', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error subscribing to channel',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=subscribe-channel.js.map

package/dist/toolkits/youtube/tools/unsubscribe-channel.d.ts

@@ -0,0 +1,26 @@
+export declare const unsubscribeChannel: import("ai").Tool<{
+    youtubeToken: string;
+    subscriptionId: string;
+}, {
+    error: string;
+    details: any;
+    subscriptionId?: undefined;
+    unsubscribed?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    subscriptionId: string;
+    unsubscribed: boolean;
+    httpStatus: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    subscriptionId?: undefined;
+    unsubscribed?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=unsubscribe-channel.d.ts.map

package/dist/toolkits/youtube/tools/unsubscribe-channel.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const unsubscribeChannel = tool({
+    description: 'Removes a subscription by subscription ID (from listUserSubscriptions). The subscription must belong to the authenticated user.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        subscriptionId: z.string().describe('Subscription ID to delete'),
+    }),
+    execute: async ({ youtubeToken, subscriptionId }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/subscriptions', {
+                method: 'DELETE',
+                query: { id: subscriptionId },
+            });
+            if (!result.ok)
+                return { error: 'Failed to unsubscribe from channel', details: result.error };
+            return { subscriptionId, unsubscribed: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error unsubscribing from channel',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=unsubscribe-channel.js.map

package/dist/toolkits/youtube/tools/update-caption.d.ts

@@ -0,0 +1,11 @@
+export declare const updateCaption: import("ai").Tool<{
+    id: string;
+    snippet: {
+        name?: string | undefined;
+        language?: string | undefined;
+        videoId?: string | undefined;
+        isDraft?: boolean | undefined;
+    };
+    youtubeToken: string;
+}, any>;
+//# sourceMappingURL=update-caption.d.ts.map

package/dist/toolkits/youtube/tools/update-caption.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const updateCaption = tool({
+    description: "Updates caption track metadata (name, language, draft status). Only specified snippet fields change; content is not re-uploaded.",
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().min(1).describe('Caption track ID from listCaptionTrack (NOT the video ID)'),
+        snippet: z.object({
+            name: z.string().max(150).optional().describe('Display name (max 150 chars)'),
+            language: z.string().optional().describe("BCP-47 language tag, e.g. 'en'"),
+            isDraft: z.boolean().optional().describe('True hides the track publicly'),
+            videoId: z.string().optional().describe('Video associated with the track'),
+        }),
+    }),
+    execute: async ({ youtubeToken, id, snippet }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/captions', {
+                method: 'PUT',
+                query: { part: 'snippet' },
+                body: { id, snippet },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update caption track', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating caption track',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-caption.js.map

package/dist/toolkits/youtube/tools/update-channel-section.d.ts

@@ -0,0 +1,15 @@
+export declare const updateChannelSection: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    snippet?: {
+        type: string;
+        title?: string | undefined;
+        position?: number | undefined;
+        channelId?: string | undefined;
+    } | undefined;
+    contentDetails?: {
+        playlists?: string[] | undefined;
+        channels?: string[] | undefined;
+    } | undefined;
+}, any>;
+//# sourceMappingURL=update-channel-section.d.ts.map

package/dist/toolkits/youtube/tools/update-channel-section.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const updateChannelSection = tool({
+    description: 'Updates a channel section (title, position, featured playlists/channels) by ID.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Channel section ID to update (required)'),
+        snippet: z.object({
+            type: z.string().describe('Section type (required by the API, e.g. multiplePlaylists)'),
+            title: z.string().max(100).optional().describe('New title (multiplePlaylists/multipleChannels only)'),
+            position: z.number().min(0).optional().describe('New zero-based position'),
+            channelId: z.string().optional().describe('Channel that published the section'),
+        }).optional(),
+        contentDetails: z.object({
+            playlists: z.array(z.string()).optional(),
+            channels: z.array(z.string()).optional(),
+        }).optional(),
+    }),
+    execute: async ({ youtubeToken, id, snippet, contentDetails }) => {
+        try {
+            const body = { id };
+            if (snippet)
+                body.snippet = snippet;
+            if (contentDetails)
+                body.contentDetails = contentDetails;
+            const result = await youtubeRequest(youtubeToken, '/channelSections', {
+                method: 'PUT',
+                query: { part: 'snippet,contentDetails' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update channel section', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating channel section',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-channel-section.js.map

package/dist/toolkits/youtube/tools/update-channel.d.ts

@@ -0,0 +1,10 @@
+export declare const updateChannel: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    onBehalfOfContentOwner?: string | undefined;
+    part?: string | undefined;
+    localizations?: Record<string, any> | undefined;
+    brandingSettings?: Record<string, any> | undefined;
+    invideoPromotion?: Record<string, any> | undefined;
+}, any>;
+//# sourceMappingURL=update-channel.d.ts.map

package/dist/toolkits/youtube/tools/update-channel.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const updateChannel = tool({
+    description: "Updates owned channel metadata (brandingSettings, invideoPromotion, localizations). Only those parts are writable.",
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe("Channel ID to update (starts with 'UC', must be owned)"),
+        part: z.string().optional().describe('Parts being set (default brandingSettings)'),
+        brandingSettings: z.record(z.any()).optional().describe('Branding settings incl. channel title, description, keywords, country'),
+        invideoPromotion: z.record(z.any()).optional().describe('Promotional campaign details'),
+        localizations: z.record(z.any()).optional().describe('Translated metadata keyed by BCP-47 code'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, id, part, brandingSettings, invideoPromotion, localizations, onBehalfOfContentOwner }) => {
+        try {
+            const body = { id };
+            if (brandingSettings)
+                body.brandingSettings = brandingSettings;
+            if (invideoPromotion)
+                body.invideoPromotion = invideoPromotion;
+            if (localizations)
+                body.localizations = localizations;
+            const result = await youtubeRequest(youtubeToken, '/channels', {
+                method: 'PUT',
+                query: { part: part ?? 'brandingSettings', onBehalfOfContentOwner },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update channel', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating channel',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-channel.js.map

package/dist/toolkits/youtube/tools/update-comment.d.ts

@@ -0,0 +1,6 @@
+export declare const updateComment: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    textOriginal: string;
+}, any>;
+//# sourceMappingURL=update-comment.d.ts.map

package/dist/toolkits/youtube/tools/update-comment.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const updateComment = tool({
+    description: 'Edits the text of an existing comment. Use to update or correct a previously posted comment.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Comment ID to update'),
+        textOriginal: z.string().min(1).describe('New comment text (replaces existing text)'),
+    }),
+    execute: async ({ youtubeToken, id, textOriginal }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/comments', {
+                method: 'PUT',
+                query: { part: 'snippet' },
+                body: { id, snippet: { textOriginal } },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update comment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating comment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-comment.js.map

package/dist/toolkits/youtube/tools/update-playlist-item.d.ts

@@ -0,0 +1,19 @@
+export declare const updatePlaylistItem: import("ai").Tool<{
+    id: string;
+    snippet: {
+        playlistId: string;
+        resourceId: {
+            videoId: string;
+            kind: string;
+        };
+        position?: number | undefined;
+    };
+    youtubeToken: string;
+    status?: {
+        privacyStatus: string;
+    } | undefined;
+    contentDetails?: Record<string, any> | undefined;
+    onBehalfOfContentOwner?: string | undefined;
+    part?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-playlist-item.d.ts.map

package/dist/toolkits/youtube/tools/update-playlist-item.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const updatePlaylistItem = tool({
+    description: 'Modifies a playlist item (position for reordering, note, privacy). The playlist must use manual sorting to change positions.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Playlist item ID to update'),
+        snippet: z.object({
+            playlistId: z.string().describe('Playlist containing the item (required)'),
+            resourceId: z.object({
+                kind: z.string().describe("Resource type, e.g. 'youtube#video'"),
+                videoId: z.string().describe('Video ID in the playlist'),
+            }),
+            position: z.number().min(0).optional().describe('New zero-based position; omit to keep current'),
+        }),
+        contentDetails: z.record(z.any()).optional().describe('Updatable content details, e.g. {note} (max 280 chars)'),
+        status: z.object({ privacyStatus: z.string() }).optional().describe('Privacy status update'),
+        part: z.string().optional().describe('Response parts (default snippet)'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, id, snippet, contentDetails, status, part, onBehalfOfContentOwner }) => {
+        try {
+            const body = { id, snippet };
+            if (contentDetails)
+                body.contentDetails = contentDetails;
+            if (status)
+                body.status = status;
+            const result = await youtubeRequest(youtubeToken, '/playlistItems', {
+                method: 'PUT',
+                query: { part: part ?? 'snippet', onBehalfOfContentOwner },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update playlist item', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating playlist item',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-playlist-item.js.map

package/dist/toolkits/youtube/tools/update-playlist.d.ts

@@ -0,0 +1,16 @@
+export declare const updatePlaylist: import("ai").Tool<{
+    id: string;
+    snippet: {
+        title: string;
+        description?: string | undefined;
+        defaultLanguage?: string | undefined;
+    };
+    youtubeToken: string;
+    status?: {
+        privacyStatus?: "private" | "public" | "unlisted" | undefined;
+        podcastStatus?: string | undefined;
+    } | undefined;
+    onBehalfOfContentOwner?: string | undefined;
+    part?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-playlist.d.ts.map

package/dist/toolkits/youtube/tools/update-playlist.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const updatePlaylist = tool({
+    description: "Modifies a playlist's metadata (title, description, privacy status) on the authenticated user channel.",
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Playlist ID to update'),
+        snippet: z.object({
+            title: z.string().describe('New playlist title (required)'),
+            description: z.string().optional().describe('New playlist description'),
+            defaultLanguage: z.string().optional().describe('BCP-47 language code'),
+        }),
+        status: z.object({
+            privacyStatus: z.enum(['public', 'private', 'unlisted']).optional(),
+            podcastStatus: z.string().optional(),
+        }).optional().describe('Privacy/podcast status update'),
+        part: z.string().optional().describe('Response parts (default snippet,status)'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, id, snippet, status, part, onBehalfOfContentOwner }) => {
+        try {
+            const body = { id, snippet };
+            if (status)
+                body.status = status;
+            const result = await youtubeRequest(youtubeToken, '/playlists', {
+                method: 'PUT',
+                query: { part: part ?? 'snippet,status', onBehalfOfContentOwner },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update playlist', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating playlist',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-playlist.js.map

package/dist/toolkits/youtube/tools/update-thumbnail.d.ts

@@ -0,0 +1,6 @@
+export declare const updateThumbnail: import("ai").Tool<{
+    youtubeToken: string;
+    videoId: string;
+    thumbnailUrl: string;
+}, any>;
+//# sourceMappingURL=update-thumbnail.d.ts.map

package/dist/toolkits/youtube/tools/update-thumbnail.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { YOUTUBE_UPLOAD_BASE, youtubeTokenField } from './client.js';
+export const updateThumbnail = tool({
+    description: 'Sets a custom thumbnail from a publicly accessible image URL (JPG/PNG/GIF, under 2MB, 1280x720 recommended). Channel must be verified and video owned.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoId: z.string().describe('Video ID to set the thumbnail for (must be owned)'),
+        thumbnailUrl: z.string().min(1).describe('Public URL of the thumbnail image'),
+    }),
+    execute: async ({ youtubeToken, videoId, thumbnailUrl }) => {
+        try {
+            const imageResponse = await fetch(thumbnailUrl);
+            if (!imageResponse.ok)
+                return { error: `Failed to fetch thumbnail image (HTTP ${imageResponse.status})` };
+            const contentType = imageResponse.headers.get('content-type') ?? 'image/jpeg';
+            const bytes = Buffer.from(await imageResponse.arrayBuffer());
+            const response = await fetch(`${YOUTUBE_UPLOAD_BASE}/thumbnails/set?videoId=${encodeURIComponent(videoId)}`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${youtubeToken}`, 'Content-Type': contentType },
+                body: bytes,
+            });
+            if (!response.ok) {
+                const details = await response.json().catch(() => ({}));
+                return { error: 'Failed to set thumbnail', details };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            return {
+                error: 'Error setting thumbnail',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-thumbnail.js.map

package/dist/toolkits/youtube/tools/update-video.d.ts

@@ -0,0 +1,10 @@
+export declare const updateVideo: import("ai").Tool<{
+    youtubeToken: string;
+    videoId: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    privacyStatus?: "private" | "public" | "unlisted" | undefined;
+    categoryId?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-video.d.ts.map

package/dist/toolkits/youtube/tools/update-video.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const updateVideo = tool({
+    description: 'Updates video metadata (title, description, tags, category, privacy) by ID. Fetches current snippet/status first so omitted fields are preserved; an empty tags list clears all tags.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoId: z.string().describe('Video ID to update (must exist)'),
+        title: z.string().max(100).optional().describe('New title (max 100 chars)'),
+        description: z.string().optional().describe('New description (max 5000 bytes)'),
+        tags: z.array(z.string()).optional().describe('New tags list; empty array removes all tags'),
+        categoryId: z.string().optional().describe('New category ID as string'),
+        privacyStatus: z.enum(['public', 'private', 'unlisted']).optional(),
+    }),
+    execute: async ({ youtubeToken, videoId, title, description, tags, categoryId, privacyStatus }) => {
+        try {
+            const current = await youtubeRequest(youtubeToken, '/videos', {
+                query: { part: 'snippet,status', id: videoId },
+            });
+            if (!current.ok)
+                return { error: 'Failed to fetch current video', details: current.error };
+            const items = current.data.items ?? [];
+            if (items.length === 0)
+                return { error: `Video not found: ${videoId}` };
+            const existing = items[0];
+            const snippet = { ...existing.snippet };
+            const status = { ...existing.status };
+            if (title !== undefined)
+                snippet.title = title;
+            if (description !== undefined)
+                snippet.description = description;
+            if (categoryId !== undefined)
+                snippet.categoryId = String(categoryId);
+            if (tags !== undefined)
+                snippet.tags = tags.map((t) => t.replace(/[<>]/g, ''));
+            if (privacyStatus !== undefined)
+                status.privacyStatus = privacyStatus;
+            const result = await youtubeRequest(youtubeToken, '/videos', {
+                method: 'PUT',
+                query: { part: 'snippet,status' },
+                body: { id: videoId, snippet, status },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update video', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating video',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-video.js.map

package/dist/toolkits/youtube/tools/upload-shared.d.ts

@@ -0,0 +1,15 @@
+export declare function fetchVideoBytes(videoUrl: string): Promise<{
+    bytes: Buffer<ArrayBuffer>;
+    contentType: string;
+}>;
+export declare function buildMultipart(metadata: Record<string, unknown>, bytes: Buffer, contentType: string): {
+    body: Buffer;
+    boundary: string;
+};
+export declare function snippetStatusVideo(title: string, description: string, categoryId: string, privacyStatus: string, tags?: string[]): {
+    snippet: Record<string, unknown>;
+    status: {
+        privacyStatus: string;
+    };
+};
+//# sourceMappingURL=upload-shared.d.ts.map

package/dist/toolkits/youtube/tools/upload-shared.js

@@ -0,0 +1,21 @@
+// @ts-nocheck
+export async function fetchVideoBytes(videoUrl) {
+    const response = await fetch(videoUrl);
+    if (!response.ok)
+        throw new Error(`Failed to fetch video file (HTTP ${response.status})`);
+    const contentType = response.headers.get('content-type') ?? 'video/mp4';
+    return { bytes: Buffer.from(await response.arrayBuffer()), contentType };
+}
+export function buildMultipart(metadata, bytes, contentType) {
+    const boundary = `rnsk-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    const header = Buffer.from(`--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${JSON.stringify(metadata)}\r\n--${boundary}\r\nContent-Type: ${contentType}\r\n\r\n`, 'utf8');
+    const footer = Buffer.from(`\r\n--${boundary}--`, 'utf8');
+    return { body: Buffer.concat([header, bytes, footer]), boundary };
+}
+export function snippetStatusVideo(title, description, categoryId, privacyStatus, tags) {
+    const snippet = { title, description, categoryId: String(categoryId) };
+    if (tags)
+        snippet.tags = tags;
+    return { snippet, status: { privacyStatus } };
+}
+//# sourceMappingURL=upload-shared.js.map

package/dist/toolkits/youtube/tools/upload-video.d.ts

@@ -0,0 +1,30 @@
+export declare const uploadVideo: import("ai").Tool<{
+    description: string;
+    title: string;
+    youtubeToken: string;
+    privacyStatus: "private" | "public" | "unlisted";
+    videoUrl: string;
+    categoryId: string;
+    tags?: string[] | undefined;
+}, {
+    error: string;
+    details: any;
+    responseData?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details?: undefined;
+    responseData?: undefined;
+    message?: undefined;
+} | {
+    responseData: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    responseData?: undefined;
+}>;
+//# sourceMappingURL=upload-video.d.ts.map