@happyvertical/smrt-video 0.30.0

package/dist/index.d.ts

@@ -0,0 +1,1277 @@
+import { Asset } from '@happyvertical/smrt-assets';
+import { AssetOptions } from '@happyvertical/smrt-assets';
+import { Content } from '@happyvertical/smrt-content';
+import { ContentOptions } from '@happyvertical/smrt-content';
+import { MediaBundleFileDescriptor } from '@happyvertical/smrt-assets';
+import { MediaBundleGpsTrackPoint } from '@happyvertical/smrt-assets';
+import { MediaBundleInspection } from '@happyvertical/smrt-assets';
+import { MediaBundleInspectionLike } from '@happyvertical/smrt-assets';
+import { MediaBundleNormalizedMetadata } from '@happyvertical/smrt-assets';
+import { MediaBundleSupportFileInspection } from '@happyvertical/smrt-assets';
+import { MediaSupportFileVisibility } from '@happyvertical/smrt-assets';
+import { PersistMediaBundleAssetInput } from '@happyvertical/smrt-assets';
+import { PersistMediaBundleAssociationInput } from '@happyvertical/smrt-assets';
+import { persistMediaBundleInspection } from '@happyvertical/smrt-assets';
+import { PersistMediaBundleInspectionOptions } from '@happyvertical/smrt-assets';
+import { PersistMediaBundleInspectionResult } from '@happyvertical/smrt-assets';
+import { PersistMediaBundleMetadataArtifactInput } from '@happyvertical/smrt-assets';
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { SmrtJunction } from '@happyvertical/smrt-core';
+import { SmrtMediaBundlePersistenceAdapter } from '@happyvertical/smrt-assets';
+import { SmrtObject } from '@happyvertical/smrt-core';
+import { SmrtObjectOptions } from '@happyvertical/smrt-core';
+import { WordTiming } from '@happyvertical/smrt-voice';
+
+/**
+ * Anchor point for character placement in scene
+ */
+export declare interface AnchorPoint {
+    /** Anchor point identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Position as normalized coordinates (0-1) */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Suggested character scale at this point */
+    suggestedScale: number;
+    /** Ground plane Y coordinate for perspective */
+    groundY: number;
+    /** Optional viewpoint this anchor belongs to */
+    viewpointId?: string;
+}
+
+/**
+ * Branding configuration for video overlays
+ */
+export declare interface BrandingConfig {
+    /** Asset ID for logo overlay */
+    logoAssetId?: string | null;
+    /** Primary brand color (hex) */
+    primaryColor?: string | null;
+    /** Background color (hex) */
+    backgroundColor?: string | null;
+    /** Lower-third template name */
+    lowerThirdTemplate?: string | null;
+    /** Font family for text overlays */
+    fontFamily?: string | null;
+    /** Whether to show news ticker */
+    tickerEnabled?: boolean;
+}
+
+/**
+ * Virtual character for AI-powered video production
+ *
+ * Character represents a virtual persona combining:
+ * - Visual identity: Seed image for I2V (image-to-video) generation
+ * - Voice identity: Link to a VoiceProfile for TTS
+ * - Branding: Logo overlays, lower-thirds, colors
+ *
+ * @example
+ * ```typescript
+ * import { Character } from '@happyvertical/smrt-video';
+ *
+ * const character = new Character({
+ *   name: 'Bentley News Anchor',
+ *   description: 'Professional news anchor for local broadcasts',
+ *   imageAssetId: 'asset-123',
+ *   voiceProfileId: 'voice-456',
+ *   brandingKit: {
+ *     logoAssetId: 'asset-789',
+ *     primaryColor: '#1a73e8',
+ *     lowerThirdTemplate: 'news-standard',
+ *     tickerEnabled: true,
+ *   },
+ * });
+ * await character.save();
+ * ```
+ */
+declare class Character extends SmrtObject {
+    /** Tenant ID for multi-tenant isolation */
+    tenantId: string | null;
+    /** Human-readable name for the character */
+    name: string;
+    /** Description of the character persona */
+    description: string | null;
+    /** Asset ID of the seed image for I2V generation */
+    imageAssetId: string | null;
+    /** Asset ID of pre-baked base motion video */
+    baseMotionAssetId: string | null;
+    /** Voice profile ID for speech synthesis */
+    voiceProfileId: string | null;
+    /** Branding configuration for video overlays */
+    brandingKit: BrandingConfig;
+    /** Character status */
+    status: CharacterStatus;
+    /** Linked performer for IP-Adapter face consistency */
+    performerId: string | null;
+    /** Default scene for this character */
+    defaultSceneId: string | null;
+    /** Scene-specific configurations */
+    sceneConfigs: CharacterSceneConfig[];
+    /** 1-1 profile record for this character */
+    profileId: string | null;
+    constructor(options?: CharacterOptions);
+    private getCharacterAssetCollection;
+    private getLegacyFieldAssetIds;
+    private setLegacyFieldAssetId;
+    private clearLegacyFieldAssetId;
+    getAssets(role?: CharacterAssetRole): Promise<Asset[]>;
+    getAssetByRole(role: CharacterAssetRole): Promise<Asset | null>;
+    addAsset(asset: Asset, role?: CharacterAssetRole, sortOrder?: number): Promise<void>;
+    removeAsset(assetId: string, role?: CharacterAssetRole): Promise<void>;
+    /**
+     * Check if the character has a pre-baked base motion video
+     * @deprecated Use getAssetByRole('base-motion') instead
+     */
+    get hasBaseMotion(): boolean;
+    /** Check if the character is complete and ready for video generation */
+    get isComplete(): boolean;
+}
+export { Character }
+export { Character as PersonalityProfile }
+
+export declare class CharacterAsset extends Asset {
+    characterId: string | null;
+    role: CharacterAssetRole;
+    constructor(options?: CharacterAssetOptions);
+}
+
+export declare interface CharacterAssetOptions extends AssetOptions {
+    /** Character this asset belongs to */
+    characterId?: string | null;
+    /** Role of this asset for the character */
+    role?: CharacterAssetRole;
+}
+
+/** Roles a character asset can play */
+export declare type CharacterAssetRole = 'seed-image' | 'base-motion' | 'logo';
+
+export declare class CharacterCollection extends SmrtCollection<Character> {
+    static readonly _itemClass: typeof Character;
+    /** Find all characters belonging to a specific tenant */
+    findByTenant(tenantId: string): Promise<Character[]>;
+    /** Find all global characters (without a tenant) */
+    findGlobal(): Promise<Character[]>;
+    /** Find characters by performer */
+    findByPerformer(performerId: string): Promise<Character[]>;
+    /** Find characters that are ready for video generation */
+    findReady(): Promise<Character[]>;
+}
+
+/**
+ * Character creation options
+ */
+declare interface CharacterOptions extends SmrtObjectOptions {
+    /** Human-readable name for the character */
+    name?: string;
+    /** Description of the character persona */
+    description?: string | null;
+    /** Asset ID of the seed image for image-to-video generation */
+    imageAssetId?: string | null;
+    /** Asset ID of pre-baked base motion video */
+    baseMotionAssetId?: string | null;
+    /** Voice profile ID for speech synthesis */
+    voiceProfileId?: string | null;
+    /** Branding configuration for video overlays */
+    brandingKit?: BrandingConfig;
+    /** Character status */
+    status?: CharacterStatus;
+    /** Linked performer for IP-Adapter face consistency */
+    performerId?: string | null;
+    /** Default scene for this character */
+    defaultSceneId?: string | null;
+    /** Scene-specific configurations */
+    sceneConfigs?: CharacterSceneConfig[];
+    /** 1-1 profile record for this character */
+    profileId?: string | null;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId?: string | null;
+}
+export { CharacterOptions }
+export { CharacterOptions as PersonalityProfileOptions }
+
+export declare class CharacterOwnedAsset extends SmrtObject {
+    tenantId: string | null;
+    characterId: string;
+    assetId: string;
+    role: CharacterAssetRole;
+    sortOrder: number;
+    constructor(options?: CharacterOwnedAssetOptions);
+}
+
+export declare class CharacterOwnedAssetCollection extends SmrtJunction<CharacterOwnedAsset> {
+    static readonly _itemClass: typeof CharacterOwnedAsset;
+    protected leftField: string;
+    protected rightField: string;
+}
+
+export declare interface CharacterOwnedAssetOptions extends SmrtObjectOptions {
+    characterId?: string;
+    assetId?: string;
+    role?: CharacterAssetRole;
+    sortOrder?: number;
+    tenantId?: string | null;
+}
+
+/**
+ * Scene-specific configuration for a character
+ */
+export declare interface CharacterSceneConfig {
+    /** Scene ID */
+    sceneId: string;
+    /** Preferred viewpoint ID (for 360° scenes) */
+    viewpointId?: string;
+    /** Anchor point ID for placement */
+    anchorPointId?: string;
+    /** Character scale in this scene */
+    scale: number;
+    /** Character position in this scene (normalized 0-1) */
+    position: {
+        x: number;
+        y: number;
+    };
+}
+
+/**
+ * Character status
+ */
+declare type CharacterStatus = 'pending' | 'ready';
+export { CharacterStatus }
+export { CharacterStatus as PersonalityProfileStatus }
+
+/**
+ * Composite job for tracking virtual production compositing
+ *
+ * @example
+ * ```typescript
+ * import { CompositeJob } from '@happyvertical/smrt-video';
+ *
+ * const job = new CompositeJob({
+ *   characterVideoAssetId: 'asset-video-123',
+ *   sceneId: 'scene-townhall',
+ *   scale: 0.8,
+ *   position: { x: 0.5, y: 0.7 },
+ * });
+ * await job.save();
+ * ```
+ */
+export declare class CompositeJob extends SmrtObject {
+    tenantId: string | null;
+    /** Character video asset ID (after lip-sync) */
+    characterVideoAssetId: string | null;
+    /** Scene ID to composite onto */
+    sceneId: string | null;
+    /** Viewpoint ID (for 360° scenes) */
+    viewpointId: string | null;
+    /** Anchor point ID for placement */
+    anchorPointId: string | null;
+    /** Character scale */
+    scale: number;
+    /** Character position (normalized 0-1) */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Job status */
+    status: CompositeJobStatus;
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Output video asset ID */
+    outputAssetId: string | null;
+    /** Error message if failed */
+    errorMessage: string | null;
+    constructor(options?: CompositeJobOptions);
+    /** Check if the job is complete */
+    get isComplete(): boolean;
+    /** Check if the job is in progress */
+    get isProcessing(): boolean;
+}
+
+/**
+ * Composite job creation options
+ */
+export declare interface CompositeJobOptions extends SmrtObjectOptions {
+    /** Character video asset ID (after lip-sync) */
+    characterVideoAssetId?: string | null;
+    /** Scene ID to composite onto */
+    sceneId?: string | null;
+    /** Viewpoint ID (for 360° scenes) */
+    viewpointId?: string | null;
+    /** Anchor point ID for placement */
+    anchorPointId?: string | null;
+    /** Character scale */
+    scale?: number;
+    /** Character position (normalized 0-1) */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Job status */
+    status?: CompositeJobStatus;
+    /** Progress percentage (0-100) */
+    progress?: number;
+    /** Output video asset ID */
+    outputAssetId?: string | null;
+    /** Error message if failed */
+    errorMessage?: string | null;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId?: string | null;
+}
+
+/**
+ * Composite job status
+ */
+export declare type CompositeJobStatus = 'pending' | 'removing_bg' | 'analyzing_light' | 'compositing' | 'complete' | 'failed';
+
+/**
+ * Lighting profile for IC-Light matching
+ */
+export declare interface LightingProfile {
+    /** Dominant light direction (normalized vector) */
+    direction?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Light color temperature (Kelvin) */
+    colorTemperature?: number;
+    /** Ambient light intensity (0-1) */
+    ambientIntensity?: number;
+    /** Key light intensity (0-1) */
+    keyLightIntensity?: number;
+    /** Shadow softness (0-1) */
+    shadowSoftness?: number;
+    /** Environment map asset ID for reflections */
+    envMapAssetId?: string;
+}
+
+export { MediaBundleFileDescriptor }
+
+export { MediaBundleGpsTrackPoint }
+
+export { MediaBundleInspection }
+
+export { MediaBundleInspectionLike }
+
+export { MediaBundleNormalizedMetadata }
+
+export { MediaBundleSupportFileInspection }
+
+export { MediaSupportFileVisibility }
+
+/**
+ * Node mapping for dynamic parameter injection
+ */
+export declare interface NodeMapping {
+    /**
+     * Node ID for anchor seed image input
+     */
+    seedImage?: string;
+    /**
+     * Node ID for TTS audio input
+     */
+    audioFile?: string;
+    /**
+     * Node ID for base motion video input
+     */
+    baseVideo?: string;
+    /**
+     * Node ID for final video output
+     */
+    outputVideo?: string;
+    /**
+     * Node ID for text prompt input
+     */
+    prompt?: string;
+    /**
+     * Node ID for negative prompt input
+     */
+    negativePrompt?: string;
+    /**
+     * Node ID for sampler/scheduler settings
+     */
+    sampler?: string;
+    /**
+     * Node ID for video duration control
+     */
+    duration?: string;
+    /**
+     * Additional custom node mappings
+     */
+    [key: string]: string | undefined;
+}
+
+/**
+ * Performer - The physical likeness/face DNA
+ *
+ * A Performer represents a person's visual identity for consistent
+ * face generation across multiple Characters. One Performer can play
+ * many Characters (e.g., same face as "Evening Anchor" and "Weekend Host").
+ *
+ * @example
+ * ```typescript
+ * import { Performer } from '@happyvertical/smrt-video';
+ *
+ * const performer = new Performer({
+ *   name: 'Alex Bentley',
+ *   dna: {
+ *     gender: 'male',
+ *     ageRange: 'adult',
+ *     ipAdapterWeight: 0.75,
+ *   },
+ *   referenceAssetIds: ['ref-img-1', 'ref-img-2'],
+ * });
+ * await performer.save();
+ * ```
+ */
+export declare class Performer extends SmrtObject {
+    tenantId: string | null;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description: string | null;
+    /** Performer DNA for consistent face generation */
+    dna: PerformerDNA;
+    /** Reference images for IP-Adapter (multiple angles/expressions) */
+    referenceAssetIds: string[];
+    /** Generated seed image asset ID */
+    seedImageAssetId: string | null;
+    /** Default voice profile for this performer */
+    voiceProfileId: string | null;
+    /** Performer status */
+    status: PerformerStatus;
+    /** 1-1 profile record for this performer */
+    profileId: string | null;
+    constructor(options?: PerformerOptions);
+    private getPerformerAssetCollection;
+    private getLegacyFieldAssetIds;
+    private setLegacyFieldAssetId;
+    private clearLegacyFieldAssetId;
+    getAssets(role?: PerformerAssetRole): Promise<Asset[]>;
+    getAssetByRole(role: PerformerAssetRole): Promise<Asset | null>;
+    addAsset(asset: Asset, role?: PerformerAssetRole, sortOrder?: number): Promise<void>;
+    removeAsset(assetId: string, role?: PerformerAssetRole): Promise<void>;
+    /** Check if the performer has reference images */
+    get hasReferences(): boolean;
+    /** Check if the performer has a face embedding */
+    get hasFaceEmbedding(): boolean;
+    /** Check if the performer is ready for generation */
+    get isReady(): boolean;
+}
+
+export declare class PerformerAsset extends Asset {
+    performerId: string | null;
+    role: PerformerAssetRole;
+    constructor(options?: PerformerAssetOptions);
+}
+
+export declare interface PerformerAssetOptions extends AssetOptions {
+    /** Performer this asset belongs to */
+    performerId?: string | null;
+    /** Role of this asset for the performer */
+    role?: PerformerAssetRole;
+}
+
+/** Roles a performer asset can play */
+export declare type PerformerAssetRole = 'reference' | 'seed';
+
+/**
+ * Performer DNA for IP-Adapter FaceID consistency
+ */
+export declare interface PerformerDNA {
+    /** Gender */
+    gender: 'male' | 'female' | 'neutral';
+    /** Age range */
+    ageRange: 'child' | 'teen' | 'young_adult' | 'adult' | 'middle_aged' | 'senior';
+    /** Face embedding for IP-Adapter FaceID (512-dim vector) */
+    faceEmbedding?: number[];
+    /** Default clothing style (can be overridden per Character) */
+    defaultClothing?: {
+        style: 'business' | 'casual' | 'formal' | 'outdoor';
+        colors?: string[];
+        description?: string;
+    };
+    /** IP-Adapter weight for consistency (0.5-1.0) */
+    ipAdapterWeight: number;
+    /** FaceID weight for face consistency */
+    faceIdWeight?: number;
+}
+
+/**
+ * Performer creation options
+ */
+export declare interface PerformerOptions extends SmrtObjectOptions {
+    /** Human-readable name */
+    name?: string;
+    /** Description */
+    description?: string | null;
+    /** Performer DNA for consistent face generation */
+    dna?: PerformerDNA;
+    /** Reference images for IP-Adapter (multiple angles/expressions) */
+    referenceAssetIds?: string[];
+    /** Generated seed image asset ID */
+    seedImageAssetId?: string | null;
+    /** Default voice profile for this performer */
+    voiceProfileId?: string | null;
+    /** Performer status */
+    status?: PerformerStatus;
+    /** 1-1 profile record for this performer */
+    profileId?: string | null;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId?: string | null;
+}
+
+export declare class PerformerOwnedAsset extends SmrtObject {
+    tenantId: string | null;
+    performerId: string;
+    assetId: string;
+    role: PerformerAssetRole;
+    sortOrder: number;
+    constructor(options?: PerformerOwnedAssetOptions);
+}
+
+export declare class PerformerOwnedAssetCollection extends SmrtJunction<PerformerOwnedAsset> {
+    static readonly _itemClass: typeof PerformerOwnedAsset;
+    protected leftField: string;
+    protected rightField: string;
+}
+
+export declare interface PerformerOwnedAssetOptions extends SmrtObjectOptions {
+    performerId?: string;
+    assetId?: string;
+    role?: PerformerAssetRole;
+    sortOrder?: number;
+    tenantId?: string | null;
+}
+
+/**
+ * Performer status
+ */
+export declare type PerformerStatus = 'pending' | 'ready';
+
+export { PersistMediaBundleAssetInput }
+
+export { PersistMediaBundleAssociationInput }
+
+export { persistMediaBundleInspection }
+
+export { PersistMediaBundleInspectionOptions }
+
+export { PersistMediaBundleInspectionResult }
+
+export { PersistMediaBundleMetadataArtifactInput }
+
+/**
+ * Render status for the composition
+ */
+export declare type RenderStatus = 'draft' | 'rendering' | 'ready' | 'failed';
+
+/**
+ * Scene for virtual production compositing
+ *
+ * Supports 360° panoramas, standard images, and video backgrounds
+ * with viewpoint extraction, lighting analysis, and character placement.
+ *
+ * @example
+ * ```typescript
+ * import { Scene } from '@happyvertical/smrt-video';
+ *
+ * const scene = new Scene({
+ *   name: 'Town Hall Exterior',
+ *   sourceAssetId: 'asset-townhall-pano',
+ *   sourceType: 'panorama_360',
+ *   projection: 'equirectangular',
+ * });
+ * await scene.save();
+ * ```
+ */
+export declare class Scene extends SmrtObject {
+    tenantId: string | null;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description: string | null;
+    /** Source media asset ID */
+    sourceAssetId: string | null;
+    /** Type of source media */
+    sourceType: SceneSourceType;
+    /** Projection type for panoramas */
+    projection: SceneProjection | null;
+    /** Extracted camera angles from 360° panoramas */
+    viewpoints: SceneViewpoint[];
+    /** Lighting analysis for IC-Light matching */
+    lightingProfile: LightingProfile | null;
+    /** Location metadata */
+    location: {
+        name: string;
+        coordinates?: {
+            lat: number;
+            lng: number;
+        };
+    } | null;
+    /** Anchor points for character placement */
+    anchorPoints: AnchorPoint[];
+    /** Scene status */
+    status: SceneStatus;
+    constructor(options?: SceneOptions);
+    private getSceneAssetCollection;
+    private getLegacyFieldAssetIds;
+    private setLegacyFieldAssetId;
+    private clearLegacyFieldAssetId;
+    getAssets(role?: SceneAssetRole): Promise<Asset[]>;
+    getAssetByRole(role: SceneAssetRole): Promise<Asset | null>;
+    addAsset(asset: Asset, role?: SceneAssetRole, sortOrder?: number): Promise<void>;
+    removeAsset(assetId: string, role?: SceneAssetRole): Promise<void>;
+    /** Check if this is a 360° panorama */
+    get isPanorama(): boolean;
+    /** Check if the scene has viewpoints extracted */
+    get hasViewpoints(): boolean;
+    /** Check if the scene is ready for compositing */
+    get isReady(): boolean;
+}
+
+export declare class SceneAsset extends Asset {
+    sceneId: string | null;
+    role: SceneAssetRole;
+    constructor(options?: SceneAssetOptions);
+}
+
+export declare interface SceneAssetOptions extends AssetOptions {
+    /** Scene this asset belongs to */
+    sceneId?: string | null;
+    /** Role of this asset for the scene */
+    role?: SceneAssetRole;
+}
+
+/** Roles a scene asset can play */
+export declare type SceneAssetRole = 'source' | 'viewpoint-extract' | 'env-map';
+
+/**
+ * Scene creation options
+ */
+export declare interface SceneOptions extends SmrtObjectOptions {
+    /** Human-readable name */
+    name?: string;
+    /** Description */
+    description?: string | null;
+    /** Source media asset ID */
+    sourceAssetId?: string | null;
+    /** Type of source media */
+    sourceType?: SceneSourceType;
+    /** Projection type for panoramas */
+    projection?: SceneProjection | null;
+    /** Extracted camera angles from 360° panoramas */
+    viewpoints?: SceneViewpoint[];
+    /** Lighting analysis for IC-Light matching */
+    lightingProfile?: LightingProfile | null;
+    /** Location metadata */
+    location?: {
+        name: string;
+        coordinates?: {
+            lat: number;
+            lng: number;
+        };
+    } | null;
+    /** Anchor points for character placement */
+    anchorPoints?: AnchorPoint[];
+    /** Scene status */
+    status?: SceneStatus;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId?: string | null;
+}
+
+export declare class SceneOwnedAsset extends SmrtObject {
+    tenantId: string | null;
+    sceneId: string;
+    assetId: string;
+    role: SceneAssetRole;
+    sortOrder: number;
+    constructor(options?: SceneOwnedAssetOptions);
+}
+
+export declare class SceneOwnedAssetCollection extends SmrtJunction<SceneOwnedAsset> {
+    static readonly _itemClass: typeof SceneOwnedAsset;
+    protected leftField: string;
+    protected rightField: string;
+}
+
+export declare interface SceneOwnedAssetOptions extends SmrtObjectOptions {
+    sceneId?: string;
+    assetId?: string;
+    role?: SceneAssetRole;
+    sortOrder?: number;
+    tenantId?: string | null;
+}
+
+/**
+ * Scene projection type
+ */
+export declare type SceneProjection = 'equirectangular' | 'cubemap';
+
+/**
+ * Scene source type
+ */
+export declare type SceneSourceType = 'image' | 'video' | 'panorama_360' | 'panorama_180';
+
+/**
+ * Scene status
+ */
+export declare type SceneStatus = 'pending' | 'processing' | 'ready' | 'failed';
+
+/**
+ * Viewpoint extracted from 360° scene
+ */
+export declare interface SceneViewpoint {
+    /** Viewpoint identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Horizontal rotation (-180 to 180°) */
+    pan: number;
+    /** Vertical rotation (-90 to 90°) */
+    tilt: number;
+    /** Field of view (60-120°) */
+    fov: number;
+    /** Generated rectilinear image asset ID */
+    extractedAssetId?: string;
+    /** Viewpoint-specific lighting profile */
+    lightingProfile?: LightingProfile;
+}
+
+export { SmrtMediaBundlePersistenceAdapter }
+
+/**
+ * Transition type to the next sequence
+ */
+export declare type TransitionType = 'none' | 'fade' | 'slide' | 'wipe';
+
+/**
+ * Publishable video composition
+ *
+ * VideoComposition is the top-level container for a rendered video.
+ * It defines the render spec and contains ordered VideoSequences.
+ *
+ * @example
+ * ```typescript
+ * import { VideoComposition } from '@happyvertical/smrt-video';
+ *
+ * const composition = new VideoComposition({
+ *   title: 'Evening News - January 25, 2026',
+ *   fps: 30,
+ *   width: 1920,
+ *   height: 1080,
+ * });
+ * await composition.save();
+ * ```
+ */
+export declare class VideoComposition extends Content {
+    /** Frames per second — everything downstream is in frames */
+    fps: number;
+    /** Render width in pixels */
+    width: number;
+    /** Render height in pixels */
+    height: number;
+    /** Computed total: sum of sequences minus transition overlaps */
+    durationInFrames: number;
+    /** Render status */
+    renderStatus: RenderStatus;
+    /** Render progress (0-100) */
+    renderProgress: number;
+    constructor(options?: VideoCompositionOptions);
+    /** Duration in seconds */
+    get durationInSeconds(): number;
+    /** Check if the composition is ready for publishing */
+    get isReady(): boolean;
+    /** Check if the composition is currently rendering */
+    get isRendering(): boolean;
+    getAssets(relationship?: string): Promise<Asset[]>;
+    getAssets(role?: VideoCompositionAssetRole): Promise<Asset[]>;
+    getAssetByRole(role: VideoCompositionAssetRole): Promise<Asset | null>;
+}
+
+export declare class VideoCompositionAsset extends Asset {
+    videoCompositionId: string | null;
+    role: VideoCompositionAssetRole;
+    constructor(options?: VideoCompositionAssetOptions);
+}
+
+export declare interface VideoCompositionAssetOptions extends AssetOptions {
+    /** VideoComposition this asset belongs to */
+    videoCompositionId?: string | null;
+    /** Role of this asset for the composition */
+    role?: VideoCompositionAssetRole;
+}
+
+/** Roles a video composition asset can play */
+export declare type VideoCompositionAssetRole = 'video' | 'audio' | 'thumbnail';
+
+export declare class VideoCompositionCollection extends SmrtCollection<VideoComposition> {
+    static readonly _itemClass: typeof VideoComposition;
+    /** Find compositions by render status */
+    findByRenderStatus(renderStatus: RenderStatus): Promise<VideoComposition[]>;
+    /** Find compositions that are ready for publishing */
+    findReady(): Promise<VideoComposition[]>;
+}
+
+/**
+ * VideoComposition creation options
+ */
+export declare interface VideoCompositionOptions extends ContentOptions {
+    /** Frames per second (e.g., 30) — everything downstream is in frames */
+    fps?: number;
+    /** Render width in pixels */
+    width?: number;
+    /** Render height in pixels */
+    height?: number;
+    /** Computed total: sum of sequences minus transition overlaps */
+    durationInFrames?: number;
+    /** Render status */
+    renderStatus?: RenderStatus;
+    /** Render progress (0-100) */
+    renderProgress?: number;
+}
+
+/**
+ * Video metadata
+ */
+export declare interface VideoMetadata {
+    /** Actual duration in seconds */
+    duration?: number;
+    /** Video resolution (e.g., "1920x1080") */
+    resolution?: string;
+    /** Aspect ratio (e.g., "16:9", "9:16") */
+    aspectRatio?: string;
+    /** Video codec (e.g., "h264", "h265") */
+    codec?: string;
+    /** Frames per second */
+    fps?: number;
+    /** File size in bytes */
+    fileSize?: number;
+    /** Word timing data from TTS for lip-sync */
+    wordTimings?: WordTiming[];
+    /** ComfyUI prompt ID for tracking */
+    comfyPromptId?: string;
+}
+
+/**
+ * Thematic section of a video composition
+ *
+ * VideoSequence groups VideoShots into a logical section. It can belong
+ * to a VideoComposition or exist standalone (e.g., during long-video generation).
+ *
+ * @example
+ * ```typescript
+ * import { VideoSequence } from '@happyvertical/smrt-video';
+ *
+ * const sequence = new VideoSequence({
+ *   title: 'Top Story',
+ *   position: 0,
+ *   transitionType: 'fade',
+ *   transitionDurationFrames: 15,
+ * });
+ * await sequence.save();
+ * ```
+ */
+export declare class VideoSequence extends Content {
+    /** Composition this sequence belongs to */
+    compositionId: string | null;
+    /** Order within composition */
+    position: number;
+    /** Computed duration: sum of shot frames */
+    durationInFrames: number;
+    /** Transition type to the next sequence */
+    transitionType: TransitionType;
+    /** Overlap frames with next sequence for transition */
+    transitionDurationFrames: number;
+    constructor(options?: VideoSequenceOptions);
+    getAssets(relationship?: string): Promise<Asset[]>;
+    getAssets(role?: VideoSequenceAssetRole): Promise<Asset[]>;
+    getAssetByRole(role: VideoSequenceAssetRole): Promise<Asset | null>;
+}
+
+export declare class VideoSequenceAsset extends Asset {
+    videoSequenceId: string | null;
+    role: VideoSequenceAssetRole;
+    constructor(options?: VideoSequenceAssetOptions);
+}
+
+export declare interface VideoSequenceAssetOptions extends AssetOptions {
+    /** VideoSequence this asset belongs to */
+    videoSequenceId?: string | null;
+    /** Role of this asset for the sequence */
+    role?: VideoSequenceAssetRole;
+}
+
+/** Roles a video sequence asset can play */
+export declare type VideoSequenceAssetRole = 'video' | 'audio' | 'thumbnail';
+
+export declare class VideoSequenceCollection extends SmrtCollection<VideoSequence> {
+    static readonly _itemClass: typeof VideoSequence;
+    /** Find sequences belonging to a composition, ordered by position */
+    findByComposition(compositionId: string): Promise<VideoSequence[]>;
+    /** Find standalone sequences (not in any composition) */
+    findStandalone(): Promise<VideoSequence[]>;
+}
+
+/**
+ * VideoSequence creation options
+ */
+export declare interface VideoSequenceOptions extends ContentOptions {
+    /** Composition this sequence belongs to (nullable — can exist standalone) */
+    compositionId?: string | null;
+    /** Order within composition */
+    position?: number;
+    /** Computed duration: sum of shot frames */
+    durationInFrames?: number;
+    /** Transition type to the next sequence */
+    transitionType?: TransitionType;
+    /** Overlap frames with next sequence for transition */
+    transitionDurationFrames?: number;
+}
+
+/**
+ * Atomic video generation unit
+ *
+ * VideoShot represents a single pipeline run producing one video clip.
+ * It can belong to a VideoSequence (for multi-segment long videos) or
+ * exist standalone. Characters are linked via the VideoShotCharacter join model.
+ *
+ * @example
+ * ```typescript
+ * import { VideoShot } from '@happyvertical/smrt-video';
+ *
+ * const shot = new VideoShot({
+ *   scriptText: 'Welcome to the evening news.',
+ *   targetDuration: 30,
+ *   title: 'Evening News - Opening',
+ * });
+ * await shot.save();
+ * ```
+ */
+declare class VideoShot extends Content {
+    /** Sequence this shot belongs to */
+    sequenceId: string | null;
+    /** Scene for this shot */
+    sceneId: string | null;
+    /** Order within sequence */
+    position: number;
+    /** Actual frame count of generated clip */
+    durationInFrames: number;
+    /** Frames to skip at start (overlap handling) */
+    trimBeforeFrames: number;
+    /** Frames to skip at end */
+    trimAfterFrames: number;
+    /** Script text to be spoken */
+    scriptText: string;
+    /** Word count in the script */
+    scriptWordCount: number;
+    /** Target duration in seconds */
+    targetDuration: number;
+    /** Video generation status */
+    shotStatus: VideoShotStatus;
+    /** Generation progress (0-100) */
+    progress: number;
+    /** Error message if status is 'failed' */
+    errorMessage: string | null;
+    /** Detailed status message for progress tracking */
+    statusMessage: string | null;
+    /** Video metadata (duration, resolution, etc.) */
+    videoMetadata: VideoMetadata;
+    constructor(options?: VideoShotOptions);
+    /** Estimate speech duration based on word count (2.7 words/sec) */
+    get estimatedDuration(): number;
+    /** Check if the script length matches target duration (+/- 15%) */
+    get isScriptLengthValid(): boolean;
+    /** Get the recommended word count for target duration */
+    get recommendedWordCount(): {
+        min: number;
+        max: number;
+        target: number;
+    };
+    /** Effective frame count after trimming */
+    get effectiveFrames(): number;
+    /** Check if video generation is in progress */
+    get isGenerating(): boolean;
+    /** Check if video is ready for publishing */
+    get isReady(): boolean;
+    getAssets(relationship?: string): Promise<Asset[]>;
+    getAssets(role?: VideoShotAssetRole): Promise<Asset[]>;
+    getAssetByRole(role: VideoShotAssetRole): Promise<Asset | null>;
+    /** Update script text and recalculate word count */
+    setScript(text: string): void;
+}
+export { VideoShot as VideoContent }
+export { VideoShot }
+
+export declare class VideoShotAsset extends Asset {
+    videoShotId: string | null;
+    role: VideoShotAssetRole;
+    constructor(options?: VideoShotAssetOptions);
+}
+
+export declare interface VideoShotAssetOptions extends AssetOptions {
+    /** VideoShot this asset belongs to */
+    videoShotId?: string | null;
+    /** Role of this asset for the shot */
+    role?: VideoShotAssetRole;
+}
+
+/** Roles a video shot asset can play */
+export declare type VideoShotAssetRole = 'video' | 'audio' | 'thumbnail';
+
+/**
+ * Join model linking a VideoShot to a Character
+ *
+ * @example
+ * ```typescript
+ * import { VideoShotCharacter } from '@happyvertical/smrt-video';
+ *
+ * const link = new VideoShotCharacter({
+ *   videoShotId: 'shot-123',
+ *   characterId: 'char-456',
+ *   role: 'primary',
+ *   position: 0,
+ * });
+ * await link.save();
+ * ```
+ */
+export declare class VideoShotCharacter extends SmrtObject {
+    tenantId: string | null;
+    /** Video shot ID */
+    videoShotId: string;
+    /** Character ID */
+    characterId: string;
+    /** Role of the character in this shot */
+    role: VideoShotCharacterRole;
+    /** Order/layer position within the shot */
+    position: number;
+    constructor(options: VideoShotCharacterOptions);
+}
+
+export declare class VideoShotCharacterCollection extends SmrtCollection<VideoShotCharacter> {
+    static readonly _itemClass: typeof VideoShotCharacter;
+    /** Find all character links for a shot, ordered by position */
+    findByShot(videoShotId: string): Promise<VideoShotCharacter[]>;
+    /** Find all shot links for a character */
+    findByCharacter(characterId: string): Promise<VideoShotCharacter[]>;
+}
+
+/**
+ * VideoShotCharacter creation options
+ */
+export declare interface VideoShotCharacterOptions extends SmrtObjectOptions {
+    /** Video shot ID */
+    videoShotId: string;
+    /** Character ID */
+    characterId: string;
+    /** Role of the character in this shot */
+    role?: VideoShotCharacterRole;
+    /** Order/layer position within the shot */
+    position?: number;
+    /** Tenant ID for multi-tenant isolation */
+    tenantId?: string | null;
+}
+
+/**
+ * Character role within a shot
+ */
+export declare type VideoShotCharacterRole = 'primary' | 'secondary' | 'background';
+
+export declare class VideoShotCollection extends SmrtCollection<VideoShot> {
+    static readonly _itemClass: typeof VideoShot;
+    /** Find shots belonging to a specific sequence, ordered by position */
+    findBySequence(sequenceId: string): Promise<VideoShot[]>;
+    /** Find shots by status */
+    findByStatus(shotStatus: VideoShotStatus): Promise<VideoShot[]>;
+    /** Find standalone shots (not in any sequence) */
+    findStandalone(): Promise<VideoShot[]>;
+}
+
+/**
+ * Video shot creation options
+ */
+declare interface VideoShotOptions extends ContentOptions {
+    /** Sequence this shot belongs to (nullable — shots can exist standalone) */
+    sequenceId?: string | null;
+    /** Scene for this shot (nullable) */
+    sceneId?: string | null;
+    /** Order within sequence */
+    position?: number;
+    /** Actual frame count of generated clip */
+    durationInFrames?: number;
+    /** Frames to skip at start (overlap handling) */
+    trimBeforeFrames?: number;
+    /** Frames to skip at end */
+    trimAfterFrames?: number;
+    /** Script text to be spoken */
+    scriptText?: string;
+    /** Word count in the script */
+    scriptWordCount?: number;
+    /** Target duration in seconds */
+    targetDuration?: number;
+    /** Video generation status */
+    shotStatus?: VideoShotStatus;
+    /** Generation progress (0-100) */
+    progress?: number;
+    /** Error message if status is 'failed' */
+    errorMessage?: string | null;
+    /** Detailed status message for progress tracking */
+    statusMessage?: string | null;
+    /** Video metadata */
+    videoMetadata?: VideoMetadata;
+}
+export { VideoShotOptions as VideoContentOptions }
+export { VideoShotOptions }
+
+/**
+ * Video shot status
+ */
+declare type VideoShotStatus = 'draft' | 'queued' | 'processing' | 'ready' | 'failed' | 'published';
+export { VideoShotStatus as VideoContentStatus }
+export { VideoShotStatus }
+
+/**
+ * ComfyUI workflow template for video generation
+ *
+ * VideoWorkflow stores ComfyUI workflow definitions with node mappings
+ * for dynamic parameter injection. This allows the Histrio agent to
+ * inject anchor images, audio, and other inputs at runtime.
+ *
+ * @example
+ * ```typescript
+ * import { VideoWorkflow } from '@happyvertical/smrt-video';
+ *
+ * const workflow = new VideoWorkflow({
+ *   name: 'Wan 2.6 + EchoMimic',
+ *   description: 'Full broadcast generation with lip-sync',
+ *   workflowType: 'broadcast',
+ *   workflowJson: comfyuiWorkflowJson,
+ *   nodeMapping: {
+ *     seedImage: '1',
+ *     audioFile: '5',
+ *     outputVideo: '12',
+ *   },
+ *   estimatedTime: 600, // 10 minutes
+ *   requiredModels: ['wan_2.6_t2v_14b_fp8', 'echomimic_v2'],
+ * });
+ * await workflow.save();
+ * ```
+ */
+export declare class VideoWorkflow extends SmrtObject {
+    /**
+     * Tenant ID for multi-tenant isolation
+     */
+    tenantId: string | null;
+    /**
+     * Human-readable name for the workflow
+     */
+    name: string;
+    /**
+     * Description of what this workflow does
+     */
+    description: string | null;
+    /**
+     * Workflow type classification
+     * - prebake: Pre-generate base motion from seed image
+     * - broadcast: Full video generation pipeline
+     * - lipsync: Lip-sync only (requires base video + audio)
+     * - postprod: Post-production overlays and effects
+     * - custom: User-defined workflow
+     */
+    workflowType: WorkflowType;
+    /**
+     * ComfyUI API format JSON
+     * This is the workflow definition that will be sent to ComfyUI
+     */
+    workflowJson: object | null;
+    /**
+     * Node ID mappings for dynamic parameter injection
+     * Maps semantic names to ComfyUI node IDs
+     */
+    nodeMapping: NodeMapping;
+    /**
+     * Estimated processing time in seconds
+     * Used for progress estimation
+     */
+    estimatedTime: number;
+    /**
+     * Whether this workflow is active/usable
+     */
+    isActive: boolean;
+    /**
+     * ComfyUI models required by this workflow
+     * Used for validation before queuing
+     */
+    requiredModels: string[];
+    constructor(options?: VideoWorkflowOptions);
+    /**
+     * Check if the workflow has all required node mappings
+     */
+    get hasRequiredMappings(): boolean;
+    /**
+     * Get a copy of the workflow JSON with injected parameters
+     *
+     * Parameter injection follows ComfyUI node structure conventions:
+     * - seedImage, audioFile, baseVideo → node.inputs.image (file path)
+     * - prompt → node.inputs.text (string)
+     * - Other parameters → node.inputs[paramKey]
+     *
+     * @param params - Key-value pairs of parameters to inject
+     * @returns Modified workflow JSON or null if no workflowJson set
+     */
+    injectParameters(params: Record<string, any>): object | null;
+}
+
+/**
+ * Video workflow creation options
+ */
+export declare interface VideoWorkflowOptions extends SmrtObjectOptions {
+    /**
+     * Human-readable name for the workflow
+     */
+    name?: string;
+    /**
+     * Description of what this workflow does
+     */
+    description?: string | null;
+    /**
+     * Workflow type classification
+     * @default 'custom'
+     */
+    workflowType?: WorkflowType;
+    /**
+     * ComfyUI API format JSON
+     */
+    workflowJson?: object | null;
+    /**
+     * Node ID mappings for dynamic parameter injection
+     */
+    nodeMapping?: NodeMapping;
+    /**
+     * Estimated processing time in seconds
+     */
+    estimatedTime?: number;
+    /**
+     * Whether this workflow is active/usable
+     * @default true
+     */
+    isActive?: boolean;
+    /**
+     * ComfyUI models required by this workflow
+     */
+    requiredModels?: string[];
+    /**
+     * Tenant ID for multi-tenant isolation
+     */
+    tenantId?: string | null;
+}
+
+/**
+ * Workflow type classification
+ */
+export declare type WorkflowType = 'prebake' | 'broadcast' | 'lipsync' | 'postprod' | 'custom';
+
+export { }