@goscribe/server 1.3.3 → 1.5.0

package/dist/services/content/media-analysis.service.js

@@ -0,0 +1,404 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { supabaseClient } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from '../workspace/workspace-kb.service.js';
+import { getUserUsage, getUserPlanLimits } from '../billing/usage.service.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
+const PROGRESS_FILENAME_MAX_CHARS = 20;
+function truncateProgressFilename(value, maxChars = PROGRESS_FILENAME_MAX_CHARS) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function buildCombinedFilenameLabel(fileNames) {
+    return truncateProgressFilename(fileNames.join(', '));
+}
+function buildProgressSteps(currentStep, currentStatus, config, overrides) {
+    const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
+    const steps = {};
+    for (let i = 0; i < PIPELINE_STEPS.length; i++) {
+        const step = PIPELINE_STEPS[i];
+        let status;
+        if (overrides?.[step]) {
+            status = overrides[step];
+        }
+        else if (i < stepIndex) {
+            status = 'completed';
+        }
+        else if (i === stepIndex) {
+            status = currentStatus;
+        }
+        else {
+            if (step === 'studyGuide' && !config.generateStudyGuide) {
+                status = 'skipped';
+            }
+            else if (step === 'flashcards' && !config.generateFlashcards) {
+                status = 'skipped';
+            }
+            else {
+                status = 'pending';
+            }
+        }
+        steps[step] = { order: i + 1, status };
+    }
+    return steps;
+}
+function buildProgress(status, filename, fileType, currentStep, currentStepStatus, config, extra) {
+    return {
+        status,
+        filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        steps: buildProgressSteps(currentStep, currentStepStatus, config, extra),
+        ...extra,
+    };
+}
+export class MediaAnalysisService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async updateAnalysisProgress(workspaceId, progress) {
+        await this.db.workspace.update({
+            where: { id: workspaceId },
+            data: { analysisProgress: progress },
+        });
+        await PusherService.emitAnalysisProgress(workspaceId, progress);
+    }
+    async uploadAndAnalyzeMedia(input, userId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+        });
+        if (!workspace) {
+            this.logger.error('Workspace not found', { workspaceId: input.workspaceId, userId });
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        }
+        if (workspace.fileBeingAnalyzed) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'File analysis is already in progress for this workspace. Please wait for it to complete.',
+            });
+        }
+        const files = await this.db.fileAsset.findMany({
+            where: {
+                id: { in: input.files.map((file) => file.id) },
+                workspaceId: input.workspaceId,
+                userId,
+            },
+        });
+        if (files.length === 0) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'No files found with the provided IDs',
+            });
+        }
+        for (const file of files) {
+            if (!file.bucket || !file.objectKey) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: `File ${file.id} does not have bucket or objectKey set`,
+                });
+            }
+        }
+        const primaryFile = files[0];
+        const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
+        const combinedFilenameLabel = buildCombinedFilenameLabel(files.map((file) => file.name));
+        try {
+            await this.db.workspace.update({
+                where: { id: input.workspaceId },
+                data: { fileBeingAnalyzed: true },
+            });
+            const genConfig = {
+                generateStudyGuide: input.generateStudyGuide,
+                generateFlashcards: input.generateFlashcards,
+            };
+            PusherService.emitAnalysisProgress(input.workspaceId, buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig));
+            try {
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig));
+            }
+            catch (error) {
+                this.logger.error('Failed to update analysis progress:', error);
+                await this.db.workspace.update({
+                    where: { id: input.workspaceId },
+                    data: { fileBeingAnalyzed: false },
+                });
+                await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+                throw error;
+            }
+            await this.updateAnalysisProgress(input.workspaceId, buildProgress('uploading', primaryFile.name, fileType, 'fileUpload', 'in_progress', genConfig));
+            for (const [fileIndex, file] of files.entries()) {
+                if (!file.bucket || !file.objectKey) {
+                    continue;
+                }
+                const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
+                const currentFileLabel = truncateProgressFilename(file.name);
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('uploading', currentFileLabel, currentFileType, 'fileUpload', 'in_progress', genConfig, {
+                    currentFileIndex: fileIndex + 1,
+                    totalFiles: files.length,
+                }));
+                const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+                    .from(file.bucket)
+                    .createSignedUrl(file.objectKey, 24 * 60 * 60);
+                if (signedUrlError) {
+                    await this.db.workspace.update({
+                        where: { id: input.workspaceId },
+                        data: { fileBeingAnalyzed: false },
+                    });
+                    throw new TRPCError({
+                        code: 'INTERNAL_SERVER_ERROR',
+                        message: `Failed to upload file`,
+                    });
+                }
+                const fileUrl = signedUrlData.signedUrl;
+                const maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
+                const processResult = await ai.backend.processFile(input.workspaceId, userId, fileUrl, currentFileType, maxPages);
+                if (processResult.status === 'error') {
+                    this.logger.error(`Failed to process file ${file.name}:`, processResult.error);
+                }
+                else {
+                    this.logger.info(`Successfully processed file ${file.name}: ${processResult.pageCount} pages`);
+                    await this.db.fileAsset.update({
+                        where: { id: file.id },
+                        data: {
+                            aiTranscription: {
+                                comprehensiveDescription: processResult.comprehensiveDescription,
+                                textContent: processResult.textContent,
+                                imageDescriptions: processResult.imageDescriptions,
+                            },
+                        },
+                    });
+                    const indexText = processResult.comprehensiveDescription ??
+                        processResult.textContent ??
+                        '';
+                    if (indexText.trim()) {
+                        workspaceKbService.indexTextAsync(input.workspaceId, userId, {
+                            sourceType: 'file',
+                            sourceId: file.id,
+                            name: file.name,
+                            text: indexText,
+                        });
+                    }
+                }
+            }
+            await this.updateAnalysisProgress(input.workspaceId, buildProgress('analyzing', combinedFilenameLabel, fileType, 'fileAnalysis', 'in_progress', genConfig));
+            try {
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('generating_artifacts', combinedFilenameLabel, fileType, 'studyGuide', 'pending', genConfig));
+            }
+            catch (error) {
+                this.logger.error('Failed to analyze files:', error);
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('error', combinedFilenameLabel, fileType, 'fileAnalysis', 'error', genConfig, {
+                    error: `Failed to analyze ${fileType}: ${error}`,
+                    studyGuide: 'skipped',
+                    flashcards: 'skipped',
+                }));
+                await this.db.workspace.update({
+                    where: { id: input.workspaceId },
+                    data: { fileBeingAnalyzed: false },
+                });
+                throw error;
+            }
+            const results = {
+                filename: primaryFile.name,
+                artifacts: {
+                    studyGuide: null,
+                    flashcards: null,
+                    worksheet: null,
+                },
+            };
+            try {
+                await ai.backend.initSession(input.workspaceId, userId);
+            }
+            catch (initError) {
+                this.logger.error('Failed to init AI session (continuing with workspace context):', initError);
+            }
+            const [usage, limits] = await Promise.all([
+                getUserUsage(userId),
+                getUserPlanLimits(userId),
+            ]);
+            if (input.generateStudyGuide) {
+                if (limits && usage.studyGuides >= limits.maxStudyGuides) {
+                    await this.updateAnalysisProgress(input.workspaceId, buildProgress('skipped', combinedFilenameLabel, fileType, 'studyGuide', 'skipped', genConfig));
+                    await PusherService.emitError(input.workspaceId, 'Study guide skipped: Limit reached.', 'study_guide');
+                    await notifyArtifactFailed(this.db, {
+                        userId,
+                        workspaceId: input.workspaceId,
+                        artifactType: ArtifactType.STUDY_GUIDE,
+                        message: 'Study guide was skipped because your plan limit was reached.',
+                    }).catch(() => { });
+                }
+                else {
+                    try {
+                        await this.updateAnalysisProgress(input.workspaceId, buildProgress('generating_study_guide', combinedFilenameLabel, fileType, 'studyGuide', 'in_progress', genConfig));
+                        const ragContext = await workspaceKbService.retrieveContext(input.workspaceId, 'study guide key concepts definitions explanations examples', 8);
+                        const content = await ai.backend.generateStudyGuide(input.workspaceId, userId, { ragContext });
+                        let artifact = await this.db.artifact.findFirst({
+                            where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+                        });
+                        if (!artifact) {
+                            artifact = await this.db.artifact.create({
+                                data: {
+                                    workspaceId: input.workspaceId,
+                                    type: ArtifactType.STUDY_GUIDE,
+                                    title: files.length === 1
+                                        ? `Study Guide - ${primaryFile.name}`
+                                        : `Study Guide - ${files.length} files`,
+                                    createdById: userId,
+                                },
+                            });
+                        }
+                        const lastVersion = await this.db.artifactVersion.findFirst({
+                            where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+                            orderBy: { version: 'desc' },
+                        });
+                        await this.db.artifactVersion.create({
+                            data: {
+                                artifactId: artifact.id,
+                                version: lastVersion ? lastVersion.version + 1 : 1,
+                                content: content,
+                                createdById: userId,
+                            },
+                        });
+                        results.artifacts.studyGuide = artifact;
+                        await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
+                        await notifyArtifactReady(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactId: artifact.id,
+                            artifactType: ArtifactType.STUDY_GUIDE,
+                            title: artifact.title,
+                        }).catch(() => { });
+                        workspaceKbService.indexTextAsync(input.workspaceId, userId, {
+                            sourceType: 'study-guide',
+                            sourceId: artifact.id,
+                            name: artifact.title,
+                            text: content,
+                        });
+                    }
+                    catch (sgError) {
+                        this.logger.error('Study guide generation failed after retries:', sgError);
+                        await PusherService.emitError(input.workspaceId, 'Study guide generation failed. Please try regenerating later.', 'study_guide');
+                        await notifyArtifactFailed(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactType: ArtifactType.STUDY_GUIDE,
+                            message: 'Study guide generation failed. Please try regenerating later.',
+                        }).catch(() => { });
+                    }
+                }
+            }
+            if (input.generateFlashcards) {
+                if (limits && usage.flashcards >= limits.maxFlashcards) {
+                    await this.updateAnalysisProgress(input.workspaceId, buildProgress('skipped', combinedFilenameLabel, fileType, 'flashcards', 'skipped', genConfig));
+                    await PusherService.emitError(input.workspaceId, 'Flashcards skipped: Limit reached.', 'flashcards');
+                    await notifyArtifactFailed(this.db, {
+                        userId,
+                        workspaceId: input.workspaceId,
+                        artifactType: ArtifactType.FLASHCARD_SET,
+                        message: 'Flashcards were skipped because your plan limit was reached.',
+                    }).catch(() => { });
+                }
+                else {
+                    try {
+                        const sgStatus = input.generateStudyGuide
+                            ? results.artifacts.studyGuide
+                                ? 'completed'
+                                : 'error'
+                            : 'skipped';
+                        await this.updateAnalysisProgress(input.workspaceId, buildProgress('generating_flashcards', combinedFilenameLabel, fileType, 'flashcards', 'in_progress', genConfig, {
+                            studyGuide: sgStatus,
+                        }));
+                        const flashcardRag = await workspaceKbService.retrieveContext(input.workspaceId, 'flashcard key concepts facts definitions questions', 8);
+                        const content = await ai.backend.generateFlashcardQuestions(input.workspaceId, userId, 10, 'medium', undefined, { ragContext: flashcardRag });
+                        const artifact = await this.db.artifact.create({
+                            data: {
+                                workspaceId: input.workspaceId,
+                                type: ArtifactType.FLASHCARD_SET,
+                                title: files.length === 1
+                                    ? `Flashcards - ${primaryFile.name}`
+                                    : `Flashcards - ${files.length} files`,
+                                createdById: userId,
+                            },
+                        });
+                        try {
+                            const parsed = typeof content === 'string' ? JSON.parse(content) : content;
+                            const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
+                            for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
+                                const card = flashcardData[i];
+                                const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
+                                const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+                                await this.db.flashcard.create({
+                                    data: {
+                                        artifactId: artifact.id,
+                                        front: front,
+                                        back: back,
+                                        order: i,
+                                        tags: ['ai-generated', 'medium'],
+                                    },
+                                });
+                            }
+                        }
+                        catch (parseError) {
+                            console.error('Failed to parse flashcard JSON or create cards in workspace router:', parseError);
+                            const lines = content.split('\n').filter((line) => line.trim());
+                            for (let i = 0; i < Math.min(lines.length, 10); i++) {
+                                const line = lines[i];
+                                if (line.includes(' - ')) {
+                                    const [front, back] = line.split(' - ');
+                                    await this.db.flashcard.create({
+                                        data: {
+                                            artifactId: artifact.id,
+                                            front: front.trim(),
+                                            back: back.trim(),
+                                            order: i,
+                                            tags: ['ai-generated', 'medium'],
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        results.artifacts.flashcards = artifact;
+                        await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+                        await notifyArtifactReady(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactId: artifact.id,
+                            artifactType: ArtifactType.FLASHCARD_SET,
+                            title: artifact.title,
+                        }).catch(() => { });
+                    }
+                    catch (fcError) {
+                        this.logger.error('Flashcard generation failed after retries:', fcError);
+                        await PusherService.emitError(input.workspaceId, 'Flashcard generation failed. Please try regenerating later.', 'flashcards');
+                        await notifyArtifactFailed(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactType: ArtifactType.FLASHCARD_SET,
+                            message: 'Flashcard generation failed. Please try regenerating later.',
+                        }).catch(() => { });
+                    }
+                }
+            }
+            await this.db.workspace.update({
+                where: { id: input.workspaceId },
+                data: { fileBeingAnalyzed: false },
+            });
+            await this.updateAnalysisProgress(input.workspaceId, {
+                ...buildProgress('completed', combinedFilenameLabel, fileType, 'flashcards', 'completed', genConfig),
+                completedAt: new Date().toISOString(),
+            });
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Failed to update analysis progress:', error);
+            await this.db.workspace.update({
+                where: { id: input.workspaceId },
+                data: { fileBeingAnalyzed: false },
+            });
+            await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+            throw error;
+        }
+    }
+}

package/dist/services/content/podcast.service.d.ts

@@ -0,0 +1,267 @@
+import type { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { BaseService } from '../base.service.js';
+export declare const speakerSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        host: "host";
+        guest: "guest";
+        expert: "expert";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const podcastInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    userPrompt: z.ZodString;
+    speakers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            host: "host";
+            guest: "guest";
+            expert: "expert";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    speed: z.ZodDefault<z.ZodNumber>;
+    generateIntro: z.ZodDefault<z.ZodBoolean>;
+    generateOutro: z.ZodDefault<z.ZodBoolean>;
+    segmentByTopics: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PodcastInput = z.infer<typeof podcastInputSchema>;
+export declare const podcastMetadataSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    totalDuration: z.ZodNumber;
+    speakers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            host: "host";
+            guest: "guest";
+            expert: "expert";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        executiveSummary: z.ZodString;
+        learningObjectives: z.ZodArray<z.ZodString>;
+        keyConcepts: z.ZodArray<z.ZodString>;
+        followUpActions: z.ZodArray<z.ZodString>;
+        targetAudience: z.ZodString;
+        prerequisites: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    generatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare class PodcastService extends BaseService {
+    constructor(db: PrismaClient);
+    listEpisodes(userId: string, workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        description: string | null;
+        metadata: {
+            title: string;
+            totalDuration: number;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+            summary: {
+                executiveSummary: string;
+                learningObjectives: string[];
+                keyConcepts: string[];
+                followUpActions: string[];
+                targetAudience: string;
+                prerequisites: string[];
+                tags: string[];
+            };
+            generatedAt: string;
+            description?: string | undefined;
+        } | null;
+        imageUrl: string | null;
+        segments: ({
+            id: string;
+            title: string;
+            audioUrl: string;
+            objectKey: string;
+            startTime: number;
+            duration: number;
+            order: number;
+        } | {
+            id: string;
+            title: string;
+            audioUrl: null;
+            objectKey: string | null;
+            startTime: number;
+            duration: number;
+            order: number;
+        })[];
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        createdById: string | null;
+        isArchived: boolean;
+    }[]>;
+    getEpisode(userId: string, episodeId: string): Promise<{
+        id: string;
+        title: string;
+        description: string | undefined;
+        metadata: {
+            title: string;
+            totalDuration: number;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+            summary: {
+                executiveSummary: string;
+                learningObjectives: string[];
+                keyConcepts: string[];
+                followUpActions: string[];
+                targetAudience: string;
+                prerequisites: string[];
+                tags: string[];
+            };
+            generatedAt: string;
+            description?: string | undefined;
+        };
+        imageUrl: string | null;
+        segments: ({
+            id: string;
+            title: string;
+            content: string;
+            audioUrl: string;
+            objectKey: string;
+            startTime: number;
+            duration: number;
+            keyPoints: string[];
+            order: number;
+        } | {
+            id: string;
+            title: string;
+            content: string;
+            audioUrl: null;
+            objectKey: string | null;
+            startTime: number;
+            duration: number;
+            keyPoints: string[];
+            order: number;
+        })[];
+        content: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    generateEpisode(userId: string, input: {
+        workspaceId: string;
+        podcastData: PodcastInput;
+    }): Promise<{
+        id: string;
+        title: any;
+        description: string | undefined;
+        metadata: {
+            title: any;
+            description: string | undefined;
+            totalDuration: number;
+            summary: any;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+            generatedAt: string;
+        };
+        content: string;
+    }>;
+    deleteSegment(segmentId: string): Promise<{
+        meta: import("@prisma/client/runtime/library").JsonValue | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        artifactId: string;
+        content: string;
+        objectKey: string | null;
+        duration: number;
+        order: number;
+        startTime: number;
+        audioUrl: string | null;
+        keyPoints: string[];
+    }>;
+    getEpisodeSchema(userId: string, episodeId: string): Promise<{
+        segments: {
+            id: string;
+            title: string;
+            startTime: number;
+            duration: number;
+            keyPoints: string[];
+            order: number;
+        }[];
+        summary: {
+            executiveSummary: string;
+            learningObjectives: string[];
+            keyConcepts: string[];
+            followUpActions: string[];
+            targetAudience: string;
+            prerequisites: string[];
+            tags: string[];
+        };
+        metadata: {
+            title: string;
+            description: string | undefined;
+            totalDuration: number;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+        };
+    }>;
+    updateEpisode(userId: string, input: {
+        episodeId: string;
+        title?: string;
+        description?: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        title: string;
+        isArchived: boolean;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        createdById: string | null;
+        description: string | null;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+        imageObjectKey: string | null;
+    }>;
+    deleteEpisode(userId: string, episodeId: string): Promise<boolean>;
+    getSegment(userId: string, segmentId: string): Promise<{
+        id: string;
+        title: string;
+        content: string;
+        startTime: number;
+        duration: number;
+        order: number;
+        keyPoints: string[];
+        audioUrl: string | null;
+        objectKey: string | null;
+        meta: import("@prisma/client/runtime/library").JsonValue;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    getAvailableVoices(): {
+        id: string;
+        name: string;
+        description: string;
+    }[];
+}