tessl/npm-mux--mux-node

Official TypeScript library providing comprehensive client access to Mux's video infrastructure API including asset management, live streaming, analytics, and webhook handling

Overview

Eval results

Files

Playback Control

Name: tessl/npm-mux--mux-node
Author: tessl

Playback utilities and access control including playback IDs, restrictions, DRM configurations, and content delivery for secure video streaming.

Capabilities

Playback ID Management

Manage playback identifiers for controlling video access and security policies.

/**
 * Retrieve playback ID information
 * @param playbackId - The playback ID
 * @returns Promise resolving to playback ID details
 */
retrieve(playbackId: string): Promise<PlaybackIDRetrieveResponse>;

interface PlaybackIDRetrieveResponse {
  /** Playback ID data */
  data?: PlaybackIDData;
}

interface PlaybackIDData {
  /** Playback ID */
  id: string;
  /** Access policy */
  policy: PlaybackPolicy;
  /** Associated object type */
  object?: {
    type: 'asset' | 'live_stream';
    id: string;
  };
  /** DRM configuration if applicable */
  drm_configuration_id?: string;
}

Playback Restrictions

Create and manage access restrictions for playback content including referrer and user agent filtering.

/**
 * Create a playback restriction
 * @param body - Restriction creation parameters
 * @returns Promise resolving to the created restriction
 */
create(body: PlaybackRestrictionCreateParams): Promise<PlaybackRestriction>;

interface PlaybackRestrictionCreateParams {
  /** Referrer domain restrictions (required) */
  referrer: ReferrerRestriction;
  /** User agent restrictions (required) */
  user_agent: UserAgentRestriction;
}

interface PlaybackRestriction {
  /** Restriction identifier */
  id: string;
  /** Referrer restrictions */
  referrer?: ReferrerRestriction;
  /** User agent restrictions */
  user_agent?: UserAgentRestriction;
  /** Creation timestamp */
  created_at: string;
}

interface ReferrerRestriction {
  /** Allowed referrer domains */
  allowed_domains?: Array<string>;
  /** Whether to allow requests with no referrer */
  allow_no_referrer?: boolean;
}

interface UserAgentRestriction {
  /** Whether to allow requests with no user agent */
  allow_no_user_agent?: boolean;
  /** Whether to allow requests from high-risk user agents */
  allow_high_risk_user_agent?: boolean;
}

/**
 * Update referrer restrictions
 * @param playbackRestrictionId - The restriction identifier
 * @param body - Referrer update parameters
 * @returns Promise resolving to updated restriction
 */
updateReferrer(
  playbackRestrictionId: string,
  body: PlaybackRestrictionUpdateReferrerParams
): Promise<PlaybackRestriction>;

/**
 * Update user agent restrictions
 * @param playbackRestrictionId - The restriction identifier
 * @param body - User agent update parameters
 * @returns Promise resolving to updated restriction
 */
updateUserAgent(
  playbackRestrictionId: string,
  body: PlaybackRestrictionUpdateUserAgentParams
): Promise<PlaybackRestriction>;

DRM Configurations

Manage DRM (Digital Rights Management) configurations for protected content delivery.

/**
 * Retrieve DRM configuration details
 * @param drmConfigurationId - The DRM configuration identifier
 * @returns Promise resolving to DRM configuration
 */
retrieve(drmConfigurationId: string): Promise<DRMConfiguration>;

/**
 * List DRM configurations
 * @param query - Listing parameters
 * @returns Paginated list of DRM configurations
 */
list(query?: DRMConfigurationListParams): PagePromise<DRMConfigurationsBasePage, DRMConfiguration>;

interface DRMConfiguration {
  /** DRM configuration identifier */
  id: string;
  /** DRM scheme type */
  scheme_id?: string;
  /** Content key policy */
  content_key_policy?: ContentKeyPolicy;
  /** License policy */
  license_policy?: LicensePolicy;
}

interface ContentKeyPolicy {
  /** Key policy identifier */
  id?: string;
  /** Policy name */
  name?: string;
}

interface LicensePolicy {
  /** License policy identifier */
  id?: string;
  /** Policy name */
  name?: string;
  /** Rental duration in seconds */
  rental_duration?: number;
  /** License duration in seconds */
  license_duration?: number;
}

Media Content Delivery

Retrieve various media formats and content including HLS manifests, MP4 files, thumbnails, and storyboards.

/**
 * Get HLS manifest for playback
 * @param playbackId - The playback ID
 * @param query - HLS parameters
 * @returns Promise resolving to HLS manifest response
 */
hls(playbackId: string, query?: PlaybackHlsParams): Promise<Response>;

interface PlaybackHlsParams {
  /** Token for signed playback IDs */
  token?: string;
  /** Additional query parameters */
  [key: string]: string | undefined;
}

/**
 * Get MP4 static rendition
 * @param playbackId - The playback ID
 * @param query - Static rendition parameters
 * @returns Promise resolving to MP4 file response
 */
staticRendition(playbackId: string, query?: PlaybackStaticRenditionParams): Promise<Response>;

interface PlaybackStaticRenditionParams {
  /** Token for signed playback IDs */
  token?: string;
  /** Download filename */
  download?: string;
}

/**
 * Get thumbnail image
 * @param playbackId - The playback ID
 * @param extension - Image format extension ('jpg' | 'png' | 'webp')
 * @param query - Thumbnail parameters
 * @returns Promise resolving to thumbnail image response
 */
thumbnail(playbackId: string, extension: 'jpg' | 'png' | 'webp', query?: PlaybackThumbnailParams): Promise<Response>;

interface PlaybackThumbnailParams {
  /** Token for signed playback IDs */
  token?: string;
  /** Thumbnail timestamp */
  time?: number;
  /** Image width */
  width?: number;
  /** Image height */
  height?: number;
  /** Fit mode */
  fit_mode?: 'preserve' | 'crop' | 'fill' | 'smartcrop';
}

/**
 * Get animated GIF or WebP
 * @param playbackId - The playback ID
 * @param extension - Image format extension ('gif' | 'webp')
 * @param query - Animated image parameters
 * @returns Promise resolving to animated image response
 */
animated(playbackId: string, extension: 'gif' | 'webp', query?: PlaybackAnimatedParams): Promise<Response>;

interface PlaybackAnimatedParams {
  /** Token for signed playback IDs */
  token?: string;
  /** Start time for animation */
  start?: number;
  /** End time for animation */
  end?: number;
  /** Image width */
  width?: number;
  /** Image height */
  height?: number;
  /** Frame rate */
  fps?: number;
}

Storyboard Access

Retrieve storyboard images and metadata for video scrubbing and preview functionality.

/**
 * Get storyboard images
 * @param playbackId - The playback ID
 * @param extension - Image format extension ('jpg' | 'png' | 'webp')
 * @param query - Storyboard parameters
 * @returns Promise resolving to storyboard response
 */
storyboard(playbackId: string, extension: 'jpg' | 'png' | 'webp', query?: PlaybackStoryboardParams): Promise<Response>;

/**
 * Get storyboard metadata
 * @param playbackId - The playback ID
 * @param query - Storyboard metadata parameters
 * @returns Promise resolving to storyboard metadata
 */
storyboardMeta(
  playbackId: string,
  query?: PlaybackStoryboardMetaParams
): Promise<PlaybackStoryboardMetaResponse>;

/**
 * Get storyboard VTT file
 * @param playbackId - The playback ID
 * @param query - Storyboard VTT parameters
 * @returns Promise resolving to VTT response
 */
storyboardVtt(
  playbackId: string,
  query?: PlaybackStoryboardVttParams
): Promise<PlaybackStoryboardVttResponse>;

interface PlaybackStoryboardMetaResponse {
  /** Storyboard metadata */
  data?: StoryboardMeta;
}

interface StoryboardMeta {
  /** Number of storyboard images */
  total_count?: number;
  /** Image width */
  width?: number;
  /** Image height */
  height?: number;
  /** Time interval between images */
  interval?: number;
}

Track and Transcript Access

Retrieve subtitle tracks and transcript data for accessibility and content analysis.

/**
 * Get track data (subtitles/audio)
 * @param playbackId - The playback ID
 * @param query - Track parameters
 * @returns Promise resolving to track response
 */
track(playbackId: string, query?: PlaybackTrackParams): Promise<PlaybackTrackResponse>;

interface PlaybackTrackParams {
  /** Token for signed playback IDs */
  token?: string;
  /** Track language code */
  language_code?: string;
  /** Track type */
  type?: 'subtitles' | 'captions';
}

interface PlaybackTrackResponse {
  /** Track data */
  data?: string;
}

/**
 * Get transcript data
 * @param playbackId - The playback ID
 * @param query - Transcript parameters
 * @returns Promise resolving to transcript response
 */
transcript(playbackId: string, query?: PlaybackTranscriptParams): Promise<PlaybackTranscriptResponse>;

interface PlaybackTranscriptParams {
  /** Token for signed playback IDs */
  token?: string;
  /** Language code for transcript */
  language_code?: string;
}

interface PlaybackTranscriptResponse {
  /** Transcript data */
  data?: TranscriptData;
}

interface TranscriptData {
  /** Transcript text */
  text?: string;
  /** Word-level timestamps */
  words?: Array<TranscriptWord>;
}

interface TranscriptWord {
  /** Word text */
  text: string;
  /** Start time in seconds */
  start: number;
  /** End time in seconds */
  end: number;
}

Usage Examples

// Get playback information
const playbackInfo = await mux.video.playbackIds.retrieve('your-playback-id');

// Create domain-based playback restriction
const restriction = await mux.video.playbackRestrictions.create({
  referrer: {
    allowed_domains: ['https://myapp.example.com', 'https://cdn.example.com'],
    allow_no_referrer: false,
  },
  user_agent: {
    allow_no_user_agent: false,
    allow_high_risk_user_agent: false,
  },
});

// Get HLS manifest with token
const hlsResponse = await mux.video.playback.hls('your-playback-id', {
  token: 'signed-playback-token',
});

// Get thumbnail at specific time
const thumbnail = await mux.video.playback.thumbnail('your-playback-id', 'jpg', {
  time: 30, // 30 seconds
  width: 640,
  height: 360,
  fit_mode: 'smartcrop',
});

// Get storyboard metadata
const storyboard = await mux.video.playback.storyboardMeta('your-playback-id');
console.log(`${storyboard.data?.total_count} storyboard images available`);

Types

type PlaybackPolicy = 'public' | 'signed' | 'drm';

interface PlaybackID {
  id: string;
  policy: PlaybackPolicy;
  drm_configuration_id?: string;
}

type FitMode = 'preserve' | 'crop' | 'fill' | 'smartcrop';

Install with Tessl CLI

npx tessl i tessl/npm-mux--mux-node

tessl/npm-mux--mux-node