@mux/ai 0.1.2 → 0.1.4

package/dist/index-DyTSka2R.d.ts

@@ -0,0 +1,144 @@
+import { A as AssetTextTrack, b as MuxAsset, e as TextChunk, C as ChunkingStrategy } from './types-ktXDZ93V.js';
+
+/**
+ * Context required to sign URLs for signed playback IDs.
+ */
+interface SigningContext {
+    /** The signing key ID from Mux dashboard. */
+    keyId: string;
+    /** The base64-encoded private key from Mux dashboard. */
+    keySecret: string;
+    /** Token expiration time (e.g. '1h', '1d'). Defaults to '1h'. */
+    expiration?: string;
+}
+
+declare const DEFAULT_STORYBOARD_WIDTH = 640;
+/**
+ * Generates a storyboard URL for the given playback ID.
+ * If a signing context is provided, the URL will be signed with a token.
+ *
+ * @param playbackId - The Mux playback ID
+ * @param width - Width of the storyboard in pixels (default: 640)
+ * @param signingContext - Optional signing context for signed playback IDs
+ * @returns Storyboard URL (signed if context provided)
+ */
+declare function getStoryboardUrl(playbackId: string, width?: number, signingContext?: SigningContext): Promise<string>;
+
+/** A single cue from a VTT file with timing info. */
+interface VTTCue {
+    startTime: number;
+    endTime: number;
+    text: string;
+}
+interface TranscriptFetchOptions {
+    languageCode?: string;
+    cleanTranscript?: boolean;
+    /** Optional signing context for signed playback IDs */
+    signingContext?: SigningContext;
+}
+interface TranscriptResult {
+    transcriptText: string;
+    transcriptUrl?: string;
+    track?: AssetTextTrack;
+}
+declare function getReadyTextTracks(asset: MuxAsset): AssetTextTrack[];
+declare function findCaptionTrack(asset: MuxAsset, languageCode?: string): AssetTextTrack | undefined;
+declare function extractTextFromVTT(vttContent: string): string;
+declare function vttTimestampToSeconds(timestamp: string): number;
+declare function extractTimestampedTranscript(vttContent: string): string;
+/**
+ * Parses VTT content into structured cues with timing.
+ *
+ * @param vttContent - Raw VTT file content
+ * @returns Array of VTT cues with start/end times and text
+ */
+declare function parseVTTCues(vttContent: string): VTTCue[];
+/**
+ * Builds a transcript URL for the given playback ID and track ID.
+ * If a signing context is provided, the URL will be signed with a token.
+ *
+ * @param playbackId - The Mux playback ID
+ * @param trackId - The text track ID
+ * @param signingContext - Optional signing context for signed playback IDs
+ * @returns Transcript URL (signed if context provided)
+ */
+declare function buildTranscriptUrl(playbackId: string, trackId: string, signingContext?: SigningContext): Promise<string>;
+declare function fetchTranscriptForAsset(asset: MuxAsset, playbackId: string, options?: TranscriptFetchOptions): Promise<TranscriptResult>;
+
+/**
+ * Simple token counter that approximates tokens by word count.
+ * For production use with OpenAI, consider using a proper tokenizer like tiktoken.
+ * This approximation is generally close enough for chunking purposes (1 token ≈ 0.75 words).
+ */
+declare function estimateTokenCount(text: string): number;
+/**
+ * Chunks text into overlapping segments based on token count.
+ *
+ * @param text - The text to chunk
+ * @param maxTokens - Maximum tokens per chunk
+ * @param overlapTokens - Number of tokens to overlap between chunks
+ * @returns Array of text chunks with metadata
+ */
+declare function chunkByTokens(text: string, maxTokens: number, overlapTokens?: number): TextChunk[];
+/**
+ * Chunks VTT cues into groups that respect natural cue boundaries.
+ * Splits at cue boundaries rather than mid-sentence, preserving accurate timestamps.
+ *
+ * @param cues - Array of VTT cues to chunk
+ * @param maxTokens - Maximum tokens per chunk
+ * @param overlapCues - Number of cues to overlap between chunks (default: 2)
+ * @returns Array of text chunks with accurate start/end times
+ */
+declare function chunkVTTCues(cues: VTTCue[], maxTokens: number, overlapCues?: number): TextChunk[];
+/**
+ * Chunks text according to the specified strategy.
+ *
+ * @param text - The text to chunk
+ * @param strategy - The chunking strategy to use
+ * @returns Array of text chunks
+ */
+declare function chunkText(text: string, strategy: ChunkingStrategy): TextChunk[];
+
+interface ThumbnailOptions {
+    /** Interval between thumbnails in seconds (default: 10) */
+    interval?: number;
+    /** Width of the thumbnail in pixels (default: 640) */
+    width?: number;
+    /** Optional signing context for signed playback IDs */
+    signingContext?: SigningContext;
+}
+/**
+ * Generates thumbnail URLs at regular intervals based on video duration.
+ * If a signing context is provided, the URLs will be signed with tokens.
+ *
+ * @param playbackId - The Mux playback ID
+ * @param duration - Video duration in seconds
+ * @param options - Thumbnail generation options
+ * @returns Array of thumbnail URLs (signed if context provided)
+ */
+declare function getThumbnailUrls(playbackId: string, duration: number, options?: ThumbnailOptions): Promise<string[]>;
+
+declare const index_DEFAULT_STORYBOARD_WIDTH: typeof DEFAULT_STORYBOARD_WIDTH;
+type index_ThumbnailOptions = ThumbnailOptions;
+type index_TranscriptFetchOptions = TranscriptFetchOptions;
+type index_TranscriptResult = TranscriptResult;
+type index_VTTCue = VTTCue;
+declare const index_buildTranscriptUrl: typeof buildTranscriptUrl;
+declare const index_chunkByTokens: typeof chunkByTokens;
+declare const index_chunkText: typeof chunkText;
+declare const index_chunkVTTCues: typeof chunkVTTCues;
+declare const index_estimateTokenCount: typeof estimateTokenCount;
+declare const index_extractTextFromVTT: typeof extractTextFromVTT;
+declare const index_extractTimestampedTranscript: typeof extractTimestampedTranscript;
+declare const index_fetchTranscriptForAsset: typeof fetchTranscriptForAsset;
+declare const index_findCaptionTrack: typeof findCaptionTrack;
+declare const index_getReadyTextTracks: typeof getReadyTextTracks;
+declare const index_getStoryboardUrl: typeof getStoryboardUrl;
+declare const index_getThumbnailUrls: typeof getThumbnailUrls;
+declare const index_parseVTTCues: typeof parseVTTCues;
+declare const index_vttTimestampToSeconds: typeof vttTimestampToSeconds;
+declare namespace index {
+  export { index_DEFAULT_STORYBOARD_WIDTH as DEFAULT_STORYBOARD_WIDTH, type index_ThumbnailOptions as ThumbnailOptions, type index_TranscriptFetchOptions as TranscriptFetchOptions, type index_TranscriptResult as TranscriptResult, type index_VTTCue as VTTCue, index_buildTranscriptUrl as buildTranscriptUrl, index_chunkByTokens as chunkByTokens, index_chunkText as chunkText, index_chunkVTTCues as chunkVTTCues, index_estimateTokenCount as estimateTokenCount, index_extractTextFromVTT as extractTextFromVTT, index_extractTimestampedTranscript as extractTimestampedTranscript, index_fetchTranscriptForAsset as fetchTranscriptForAsset, index_findCaptionTrack as findCaptionTrack, index_getReadyTextTracks as getReadyTextTracks, index_getStoryboardUrl as getStoryboardUrl, index_getThumbnailUrls as getThumbnailUrls, index_parseVTTCues as parseVTTCues, index_vttTimestampToSeconds as vttTimestampToSeconds };
+}
+
+export { DEFAULT_STORYBOARD_WIDTH as D, type ThumbnailOptions as T, type VTTCue as V, chunkVTTCues as a, chunkText as b, chunkByTokens as c, getThumbnailUrls as d, estimateTokenCount as e, type TranscriptFetchOptions as f, getStoryboardUrl as g, type TranscriptResult as h, index as i, getReadyTextTracks as j, findCaptionTrack as k, extractTextFromVTT as l, extractTimestampedTranscript as m, buildTranscriptUrl as n, fetchTranscriptForAsset as o, parseVTTCues as p, vttTimestampToSeconds as v };

package/dist/index-vJ5r2FNm.d.mts

@@ -0,0 +1,477 @@
+import { z } from 'zod';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAI } from '@ai-sdk/openai';
+import { h as TokenUsage, a as MuxAIOptions, I as ImageSubmissionMode, C as ChunkingStrategy, g as VideoEmbeddingsResult, T as ToneType } from './types-ktXDZ93V.mjs';
+import { Buffer } from 'node:buffer';
+
+interface ImageDownloadOptions {
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Maximum number of retry attempts (default: 3) */
+    retries?: number;
+    /** Base delay between retries in milliseconds (default: 1000) */
+    retryDelay?: number;
+    /** Maximum delay between retries in milliseconds (default: 10000) */
+    maxRetryDelay?: number;
+    /** Whether to use exponential backoff (default: true) */
+    exponentialBackoff?: boolean;
+}
+
+/**
+ * A single section of a prompt, rendered as an XML-like tag.
+ */
+interface PromptSection {
+    /** The XML tag name for this section */
+    tag: string;
+    /** The content inside the tag */
+    content: string;
+    /** Optional attributes to add to the tag (e.g., { format: "plain text" }) */
+    attributes?: Record<string, string>;
+}
+/**
+ * Configuration for building a prompt section.
+ * Can be a full PromptSection object, just a string (content only), or undefined to use default.
+ */
+type SectionOverride = string | PromptSection | undefined;
+/**
+ * User-provided overrides for prompt sections.
+ * Each key can override the corresponding section's content or full definition.
+ */
+type PromptOverrides<TSections extends string> = Partial<Record<TSections, SectionOverride>>;
+
+type SupportedProvider = "openai" | "anthropic" | "google";
+type SupportedEmbeddingProvider = "openai" | "google";
+type OpenAIModelId = Parameters<ReturnType<typeof createOpenAI>["chat"]>[0];
+type AnthropicModelId = Parameters<ReturnType<typeof createAnthropic>["chat"]>[0];
+type GoogleModelId = Parameters<ReturnType<typeof createGoogleGenerativeAI>["chat"]>[0];
+type OpenAIEmbeddingModelId = Parameters<ReturnType<typeof createOpenAI>["embedding"]>[0];
+type GoogleEmbeddingModelId = Parameters<ReturnType<typeof createGoogleGenerativeAI>["textEmbeddingModel"]>[0];
+interface ModelIdByProvider {
+    openai: OpenAIModelId;
+    anthropic: AnthropicModelId;
+    google: GoogleModelId;
+}
+interface EmbeddingModelIdByProvider {
+    openai: OpenAIEmbeddingModelId;
+    google: GoogleEmbeddingModelId;
+}
+
+/** Structured payload returned from `hasBurnedInCaptions`. */
+interface BurnedInCaptionsResult {
+    assetId: string;
+    hasBurnedInCaptions: boolean;
+    confidence: number;
+    detectedLanguage: string | null;
+    storyboardUrl: string;
+    /** Token usage from the AI provider (for efficiency/cost analysis). */
+    usage?: TokenUsage;
+}
+/**
+ * Sections of the burned-in captions user prompt that can be overridden.
+ * Use these to customize the AI's behavior for your specific use case.
+ */
+type BurnedInCaptionsPromptSections = "task" | "analysisSteps" | "positiveIndicators" | "negativeIndicators";
+/**
+ * Override specific sections of the burned-in captions prompt.
+ * Each key corresponds to a section that can be customized.
+ *
+ * @example
+ * ```typescript
+ * const result = await hasBurnedInCaptions(assetId, {
+ *   promptOverrides: {
+ *     task: 'Detect any text overlays in the video frames.',
+ *     positiveIndicators: 'Classify as captions if text appears consistently.',
+ *   },
+ * });
+ * ```
+ */
+type BurnedInCaptionsPromptOverrides = PromptOverrides<BurnedInCaptionsPromptSections>;
+/** Configuration accepted by `hasBurnedInCaptions`. */
+interface BurnedInCaptionsOptions extends MuxAIOptions {
+    /** AI provider used for storyboard inspection (defaults to 'openai'). */
+    provider?: SupportedProvider;
+    /** Provider-specific model identifier. */
+    model?: ModelIdByProvider[SupportedProvider];
+    /** Transport used for storyboard submission (defaults to 'url'). */
+    imageSubmissionMode?: ImageSubmissionMode;
+    /** Download tuning used when `imageSubmissionMode` === 'base64'. */
+    imageDownloadOptions?: ImageDownloadOptions;
+    /**
+     * Override specific sections of the user prompt.
+     * Useful for customizing the AI's detection criteria for specific use cases.
+     */
+    promptOverrides?: BurnedInCaptionsPromptOverrides;
+}
+/** Schema used to validate burned-in captions analysis responses. */
+declare const burnedInCaptionsSchema: z.ZodObject<{
+    hasBurnedInCaptions: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    detectedLanguage: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    hasBurnedInCaptions: boolean;
+    confidence: number;
+    detectedLanguage: string | null;
+}, {
+    hasBurnedInCaptions: boolean;
+    confidence: number;
+    detectedLanguage: string | null;
+}>;
+/** Inferred shape returned from the burned-in captions schema. */
+type BurnedInCaptionsAnalysis = z.infer<typeof burnedInCaptionsSchema>;
+declare function hasBurnedInCaptions(assetId: string, options?: BurnedInCaptionsOptions): Promise<BurnedInCaptionsResult>;
+
+declare const chapterSchema: z.ZodObject<{
+    startTime: z.ZodNumber;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    startTime: number;
+    title: string;
+}, {
+    startTime: number;
+    title: string;
+}>;
+type Chapter = z.infer<typeof chapterSchema>;
+declare const chaptersSchema: z.ZodObject<{
+    chapters: z.ZodArray<z.ZodObject<{
+        startTime: z.ZodNumber;
+        title: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        startTime: number;
+        title: string;
+    }, {
+        startTime: number;
+        title: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    chapters: {
+        startTime: number;
+        title: string;
+    }[];
+}, {
+    chapters: {
+        startTime: number;
+        title: string;
+    }[];
+}>;
+type ChaptersType = z.infer<typeof chaptersSchema>;
+/** Structured return payload from `generateChapters`. */
+interface ChaptersResult {
+    assetId: string;
+    languageCode: string;
+    chapters: Chapter[];
+}
+/** Configuration accepted by `generateChapters`. */
+interface ChaptersOptions extends MuxAIOptions {
+    /** AI provider used to interpret the transcript (defaults to 'openai'). */
+    provider?: SupportedProvider;
+    /** Provider-specific model identifier. */
+    model?: ModelIdByProvider[SupportedProvider];
+}
+declare function generateChapters(assetId: string, languageCode: string, options?: ChaptersOptions): Promise<ChaptersResult>;
+
+/** Configuration accepted by `generateVideoEmbeddings`. */
+interface EmbeddingsOptions extends MuxAIOptions {
+    /** AI provider used to generate embeddings (defaults to 'openai'). */
+    provider?: SupportedEmbeddingProvider;
+    /** Provider-specific model identifier (defaults to text-embedding-3-small for OpenAI). */
+    model?: EmbeddingModelIdByProvider[SupportedEmbeddingProvider];
+    /** Language code for transcript selection (defaults to first available). */
+    languageCode?: string;
+    /** Chunking strategy configuration (defaults to token-based with 500 tokens, 100 overlap). */
+    chunkingStrategy?: ChunkingStrategy;
+    /** Maximum number of chunks to process concurrently (defaults to 5). */
+    batchSize?: number;
+}
+/**
+ * Generates vector embeddings for a video asset's transcript.
+ *
+ * This function:
+ * 1. Fetches the video transcript from Mux
+ * 2. Chunks the transcript according to the specified strategy
+ * 3. Generates embeddings for each chunk using the specified AI provider
+ * 4. Returns both individual chunk embeddings and an averaged embedding
+ *
+ * @param assetId - Mux asset ID
+ * @param options - Configuration options
+ * @returns Video embeddings result with chunks and averaged embedding
+ *
+ * @example
+ * ```typescript
+ * const embeddings = await generateVideoEmbeddings("asset-id", {
+ *   provider: "openai",
+ *   chunkingStrategy: { type: "token", maxTokens: 500, overlap: 100 },
+ * });
+ *
+ * // Store in vector database
+ * for (const chunk of embeddings.chunks) {
+ *   await db.insert({
+ *     assetId: embeddings.assetId,
+ *     chunkId: chunk.chunkId,
+ *     embedding: chunk.embedding,
+ *     metadata: chunk.metadata,
+ *   });
+ * }
+ * ```
+ */
+declare function generateVideoEmbeddings(assetId: string, options?: EmbeddingsOptions): Promise<VideoEmbeddingsResult>;
+
+/** Per-thumbnail moderation result returned from `getModerationScores`. */
+interface ThumbnailModerationScore {
+    url: string;
+    sexual: number;
+    violence: number;
+    error: boolean;
+}
+/** Aggregated moderation payload returned from `getModerationScores`. */
+interface ModerationResult {
+    assetId: string;
+    thumbnailScores: ThumbnailModerationScore[];
+    maxScores: {
+        sexual: number;
+        violence: number;
+    };
+    exceedsThreshold: boolean;
+    thresholds: {
+        sexual: number;
+        violence: number;
+    };
+}
+/** Provider list accepted by `getModerationScores`. */
+type ModerationProvider = "openai" | "hive";
+type HiveModerationSource = {
+    kind: "url";
+    value: string;
+} | {
+    kind: "file";
+    buffer: Buffer;
+    contentType: string;
+};
+interface HiveModerationOutput {
+    classes?: Array<{
+        class: string;
+        score: number;
+    }>;
+}
+/** Configuration accepted by `getModerationScores`. */
+interface ModerationOptions extends MuxAIOptions {
+    /** Provider used for moderation (defaults to 'openai'). */
+    provider?: ModerationProvider;
+    /** OpenAI moderation model identifier (defaults to 'omni-moderation-latest'). */
+    model?: string;
+    /** Override the default sexual/violence thresholds (0-1). */
+    thresholds?: {
+        sexual?: number;
+        violence?: number;
+    };
+    /** Interval between storyboard thumbnails in seconds (defaults to 10). */
+    thumbnailInterval?: number;
+    /** Width of storyboard thumbnails in pixels (defaults to 640). */
+    thumbnailWidth?: number;
+    /** Max concurrent moderation requests (defaults to 5). */
+    maxConcurrent?: number;
+    /** Transport used for thumbnails (defaults to 'url'). */
+    imageSubmissionMode?: ImageSubmissionMode;
+    /** Download tuning used when `imageSubmissionMode` === 'base64'. */
+    imageDownloadOptions?: ImageDownloadOptions;
+}
+/**
+ * Moderate a Mux asset's thumbnails.
+ * - provider 'openai' uses OpenAI's hosted moderation endpoint (requires OPENAI_API_KEY)
+ */
+declare function getModerationScores(assetId: string, options?: ModerationOptions): Promise<ModerationResult>;
+
+declare const SUMMARY_KEYWORD_LIMIT = 10;
+declare const summarySchema: z.ZodObject<{
+    keywords: z.ZodArray<z.ZodString, "many">;
+    title: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    keywords: string[];
+    description: string;
+}, {
+    title: string;
+    keywords: string[];
+    description: string;
+}>;
+type SummaryType = z.infer<typeof summarySchema>;
+/** Structured return payload for `getSummaryAndTags`. */
+interface SummaryAndTagsResult {
+    /** Asset ID passed into the workflow. */
+    assetId: string;
+    /** Short headline generated from the storyboard. */
+    title: string;
+    /** Longer description of the detected content. */
+    description: string;
+    /** Up to 10 keywords extracted by the model. */
+    tags: string[];
+    /** Storyboard image URL that was analyzed. */
+    storyboardUrl: string;
+}
+/**
+ * Sections of the summarization user prompt that can be overridden.
+ * Use these to customize the AI's behavior for your specific use case.
+ */
+type SummarizationPromptSections = "task" | "title" | "description" | "keywords" | "qualityGuidelines";
+/**
+ * Override specific sections of the summarization prompt.
+ * Each key corresponds to a section that can be customized.
+ *
+ * @example
+ * ```typescript
+ * const result = await getSummaryAndTags(assetId, {
+ *   promptOverrides: {
+ *     task: 'Generate SEO-optimized metadata for this product video.',
+ *     title: 'Create a click-worthy title under 60 characters for YouTube.',
+ *   },
+ * });
+ * ```
+ */
+type SummarizationPromptOverrides = PromptOverrides<SummarizationPromptSections>;
+/** Configuration accepted by `getSummaryAndTags`. */
+interface SummarizationOptions extends MuxAIOptions {
+    /** AI provider to run (defaults to 'openai'). */
+    provider?: SupportedProvider;
+    /** Provider-specific chat model identifier. */
+    model?: ModelIdByProvider[SupportedProvider];
+    /** Prompt tone shim applied to the system instruction (defaults to 'normal'). */
+    tone?: ToneType;
+    /** Fetch the transcript and send it alongside the storyboard (defaults to true). */
+    includeTranscript?: boolean;
+    /** Strip timestamps/markup from transcripts before including them (defaults to true). */
+    cleanTranscript?: boolean;
+    /** How storyboard frames should be delivered to the provider (defaults to 'url'). */
+    imageSubmissionMode?: ImageSubmissionMode;
+    /** Fine-tune storyboard downloads when `imageSubmissionMode` === 'base64'. */
+    imageDownloadOptions?: ImageDownloadOptions;
+    /**
+     * Override specific sections of the user prompt.
+     * Useful for customizing the AI's output for specific use cases (SEO, social media, etc.)
+     */
+    promptOverrides?: SummarizationPromptOverrides;
+}
+declare function getSummaryAndTags(assetId: string, options?: SummarizationOptions): Promise<SummaryAndTagsResult>;
+
+/** Output returned from `translateAudio`. */
+interface AudioTranslationResult {
+    assetId: string;
+    targetLanguageCode: string;
+    dubbingId: string;
+    uploadedTrackId?: string;
+    presignedUrl?: string;
+}
+/** Configuration accepted by `translateAudio`. */
+interface AudioTranslationOptions extends MuxAIOptions {
+    /** Audio dubbing provider (currently ElevenLabs only). */
+    provider?: "elevenlabs";
+    /** Number of speakers supplied to ElevenLabs (0 = auto-detect, default). */
+    numSpeakers?: number;
+    /** Optional override for the S3-compatible endpoint used for uploads. */
+    s3Endpoint?: string;
+    /** S3 region (defaults to env.S3_REGION or 'auto'). */
+    s3Region?: string;
+    /** Bucket that will store dubbed audio files. */
+    s3Bucket?: string;
+    /** Access key ID used for uploads. */
+    s3AccessKeyId?: string;
+    /** Secret access key used for uploads. */
+    s3SecretAccessKey?: string;
+    /**
+     * When true (default) the dubbed audio file is uploaded to the configured
+     * bucket and attached to the Mux asset.
+     */
+    uploadToMux?: boolean;
+    /** Override for env.ELEVENLABS_API_KEY. */
+    elevenLabsApiKey?: string;
+}
+declare function translateAudio(assetId: string, toLanguageCode: string, options?: AudioTranslationOptions): Promise<AudioTranslationResult>;
+
+/** Output returned from `translateCaptions`. */
+interface TranslationResult {
+    assetId: string;
+    sourceLanguageCode: string;
+    targetLanguageCode: string;
+    originalVtt: string;
+    translatedVtt: string;
+    uploadedTrackId?: string;
+    presignedUrl?: string;
+}
+/** Configuration accepted by `translateCaptions`. */
+interface TranslationOptions<P extends SupportedProvider = SupportedProvider> extends MuxAIOptions {
+    /** Provider responsible for the translation. */
+    provider: P;
+    /** Provider-specific chat model identifier. */
+    model?: ModelIdByProvider[P];
+    /** Optional override for the S3-compatible endpoint used for uploads. */
+    s3Endpoint?: string;
+    /** S3 region (defaults to env.S3_REGION or 'auto'). */
+    s3Region?: string;
+    /** Bucket that will store translated VTT files. */
+    s3Bucket?: string;
+    /** Access key ID used for uploads. */
+    s3AccessKeyId?: string;
+    /** Secret access key used for uploads. */
+    s3SecretAccessKey?: string;
+    /**
+     * When true (default) the translated VTT is uploaded to the configured
+     * bucket and attached to the Mux asset.
+     */
+    uploadToMux?: boolean;
+}
+/** Schema used when requesting caption translation from a language model. */
+declare const translationSchema: z.ZodObject<{
+    translation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    translation: string;
+}, {
+    translation: string;
+}>;
+/** Inferred shape returned by `translationSchema`. */
+type TranslationPayload = z.infer<typeof translationSchema>;
+declare function translateCaptions<P extends SupportedProvider = SupportedProvider>(assetId: string, fromLanguageCode: string, toLanguageCode: string, options: TranslationOptions<P>): Promise<TranslationResult>;
+
+type index_AudioTranslationOptions = AudioTranslationOptions;
+type index_AudioTranslationResult = AudioTranslationResult;
+type index_BurnedInCaptionsAnalysis = BurnedInCaptionsAnalysis;
+type index_BurnedInCaptionsOptions = BurnedInCaptionsOptions;
+type index_BurnedInCaptionsPromptOverrides = BurnedInCaptionsPromptOverrides;
+type index_BurnedInCaptionsPromptSections = BurnedInCaptionsPromptSections;
+type index_BurnedInCaptionsResult = BurnedInCaptionsResult;
+type index_Chapter = Chapter;
+type index_ChaptersOptions = ChaptersOptions;
+type index_ChaptersResult = ChaptersResult;
+type index_ChaptersType = ChaptersType;
+type index_EmbeddingsOptions = EmbeddingsOptions;
+type index_HiveModerationOutput = HiveModerationOutput;
+type index_HiveModerationSource = HiveModerationSource;
+type index_ModerationOptions = ModerationOptions;
+type index_ModerationProvider = ModerationProvider;
+type index_ModerationResult = ModerationResult;
+declare const index_SUMMARY_KEYWORD_LIMIT: typeof SUMMARY_KEYWORD_LIMIT;
+type index_SummarizationOptions = SummarizationOptions;
+type index_SummarizationPromptOverrides = SummarizationPromptOverrides;
+type index_SummarizationPromptSections = SummarizationPromptSections;
+type index_SummaryAndTagsResult = SummaryAndTagsResult;
+type index_SummaryType = SummaryType;
+type index_ThumbnailModerationScore = ThumbnailModerationScore;
+type index_TranslationOptions<P extends SupportedProvider = SupportedProvider> = TranslationOptions<P>;
+type index_TranslationPayload = TranslationPayload;
+type index_TranslationResult = TranslationResult;
+declare const index_burnedInCaptionsSchema: typeof burnedInCaptionsSchema;
+declare const index_chapterSchema: typeof chapterSchema;
+declare const index_chaptersSchema: typeof chaptersSchema;
+declare const index_generateChapters: typeof generateChapters;
+declare const index_generateVideoEmbeddings: typeof generateVideoEmbeddings;
+declare const index_getModerationScores: typeof getModerationScores;
+declare const index_getSummaryAndTags: typeof getSummaryAndTags;
+declare const index_hasBurnedInCaptions: typeof hasBurnedInCaptions;
+declare const index_summarySchema: typeof summarySchema;
+declare const index_translateAudio: typeof translateAudio;
+declare const index_translateCaptions: typeof translateCaptions;
+declare const index_translationSchema: typeof translationSchema;
+declare namespace index {
+  export { type index_AudioTranslationOptions as AudioTranslationOptions, type index_AudioTranslationResult as AudioTranslationResult, type index_BurnedInCaptionsAnalysis as BurnedInCaptionsAnalysis, type index_BurnedInCaptionsOptions as BurnedInCaptionsOptions, type index_BurnedInCaptionsPromptOverrides as BurnedInCaptionsPromptOverrides, type index_BurnedInCaptionsPromptSections as BurnedInCaptionsPromptSections, type index_BurnedInCaptionsResult as BurnedInCaptionsResult, type index_Chapter as Chapter, type index_ChaptersOptions as ChaptersOptions, type index_ChaptersResult as ChaptersResult, type index_ChaptersType as ChaptersType, type index_EmbeddingsOptions as EmbeddingsOptions, type index_HiveModerationOutput as HiveModerationOutput, type index_HiveModerationSource as HiveModerationSource, type index_ModerationOptions as ModerationOptions, type index_ModerationProvider as ModerationProvider, type index_ModerationResult as ModerationResult, index_SUMMARY_KEYWORD_LIMIT as SUMMARY_KEYWORD_LIMIT, type index_SummarizationOptions as SummarizationOptions, type index_SummarizationPromptOverrides as SummarizationPromptOverrides, type index_SummarizationPromptSections as SummarizationPromptSections, type index_SummaryAndTagsResult as SummaryAndTagsResult, type index_SummaryType as SummaryType, type index_ThumbnailModerationScore as ThumbnailModerationScore, type index_TranslationOptions as TranslationOptions, type index_TranslationPayload as TranslationPayload, type index_TranslationResult as TranslationResult, index_burnedInCaptionsSchema as burnedInCaptionsSchema, index_chapterSchema as chapterSchema, index_chaptersSchema as chaptersSchema, index_generateChapters as generateChapters, index_generateVideoEmbeddings as generateVideoEmbeddings, index_getModerationScores as getModerationScores, index_getSummaryAndTags as getSummaryAndTags, index_hasBurnedInCaptions as hasBurnedInCaptions, index_summarySchema as summarySchema, index_translateAudio as translateAudio, index_translateCaptions as translateCaptions, index_translationSchema as translationSchema };
+}
+
+export { type AudioTranslationResult as A, type BurnedInCaptionsResult as B, type Chapter as C, translateAudio as D, type EmbeddingsOptions as E, type TranslationResult as F, type TranslationOptions as G, type HiveModerationSource as H, translationSchema as I, type TranslationPayload as J, translateCaptions as K, type ModerationResult as M, SUMMARY_KEYWORD_LIMIT as S, type ThumbnailModerationScore as T, type BurnedInCaptionsPromptSections as a, type BurnedInCaptionsPromptOverrides as b, type BurnedInCaptionsOptions as c, burnedInCaptionsSchema as d, type BurnedInCaptionsAnalysis as e, chapterSchema as f, chaptersSchema as g, hasBurnedInCaptions as h, index as i, type ChaptersType as j, type ChaptersResult as k, type ChaptersOptions as l, generateChapters as m, generateVideoEmbeddings as n, type ModerationProvider as o, type HiveModerationOutput as p, type ModerationOptions as q, getModerationScores as r, summarySchema as s, type SummaryType as t, type SummaryAndTagsResult as u, type SummarizationPromptSections as v, type SummarizationPromptOverrides as w, type SummarizationOptions as x, getSummaryAndTags as y, type AudioTranslationOptions as z };

package/dist/index.d.mts

@@ -0,0 +1,13 @@
+export { i as primitives } from './index-BNnz9P_5.mjs';
+export { A as AssetTextTrack, f as ChunkEmbedding, C as ChunkingStrategy, I as ImageSubmissionMode, M as MuxAIConfig, a as MuxAIOptions, b as MuxAsset, c as PlaybackAsset, P as PlaybackPolicy, e as TextChunk, d as TokenChunkingConfig, h as TokenUsage, T as ToneType, V as VTTChunkingConfig, g as VideoEmbeddingsResult } from './types-ktXDZ93V.mjs';
+export { i as workflows } from './index-vJ5r2FNm.mjs';
+import '@mux/mux-node';
+import 'zod';
+import '@ai-sdk/anthropic';
+import '@ai-sdk/google';
+import '@ai-sdk/openai';
+import 'node:buffer';
+
+declare const version = "0.1.0";
+
+export { version };