Content Types

data class ContentItem(
    val id: String,
    val playbackId: String?,
    val title: String,
    val description: String?,
    val duration: Double,
    val streamingUrl: String,
    val thumbnailUrl: String,
    val captionTracks: List<CaptionTrack>,
    val customMetadata: Map<String, JsonValue>?,
    val author: String?,
    val articleUrl: String?,
    val commentCount: Int?,
    val fallbackUrl: String?
)

interface ContentItem {
  id: string;
  playbackId?: string;
  title: string;
  description?: string;
  duration: number;
  streamingUrl: string;
  thumbnailUrl: string;
  captionTracks: CaptionTrack[];
  customMetadata?: Record<string, JsonValue>;
  author?: string;
  articleUrl?: string;
  commentCount?: number;
  fallbackUrl?: string;
}

// ContentItem shape
{
  id: 'string',
  playbackId: 'string',
  title: 'string',
  description: 'string',
  duration: 30.5,
  streamingUrl: 'https://...',
  thumbnailUrl: 'https://...',
  captionTracks: [{ language: 'en', label: 'English', source: 'generated', url: '...' }],
  customMetadata: { category: 'Sports' },
  author: 'Jane Doe',
  articleUrl: 'https://...',
  commentCount: 5,
  fallbackUrl: 'https://cdn.example.com/video.mp4',
}

data class CaptionTrack(
    val language: String,
    val label: String,
    val source: CaptionSource,
    val url: String?
)

enum class CaptionSource {
    EMBEDDED, EXTERNAL, GENERATED
}

interface CaptionTrack {
  language: string;
  label: string;
  source: "embedded" | "external" | "generated";
  url?: string;
}

{
  language: 'en',
  label: 'English',
  source: 'generated', // 'embedded' | 'external' | 'generated'
  url: 'https://...',  // null for embedded tracks
}

val section = item.customMetadata?.get("section")?.asString()
sectionLabel.text = section?.uppercase()

const section = item.customMetadata?.["section"];
if (typeof section === "string") {
  return <Text>{section.toUpperCase()}</Text>;
}

const section = item.customMetadata?.category;
if (typeof section === 'string') {
  document.getElementById('section').textContent = section.toUpperCase();
}

sealed class FeedInput {
    data class Video(
        val playbackId: String,
        val fallbackUrl: String? = null
    ) : FeedInput()
    // other cases: ImageCarousel, VideoCarousel
}

type FeedInput =
  | { type: 'video'; playbackId: string; origin?: ContentOrigin; fallbackUrl?: string }
  | { type: 'imageCarousel'; item: ImageCarouselItem }
  | { type: 'videoCarousel'; item: VideoCarouselInput };

type ContentOrigin = 'ios_upload' | 'other';

data class VideoCarouselVideoInput(
    val playbackId: String,
    val fallbackUrl: String? = null
)

interface VideoCarouselVideoInput {
  playbackId: string;
  origin?: ContentOrigin;
  fallbackUrl?: string;
}

data class ImageCarouselItem(
    val id: String,
    val images: List<CarouselImage>,
    val autoScrollInterval: Double?,
    val caption: String?,
    val title: String?,
    val description: String?,
    val author: String?,
    val section: String?,
    val articleUrl: String?
)

data class CarouselImage(
    val url: String,
    val alt: String?
)

interface ImageCarouselItem {
  id: string;
  images: CarouselImage[];
  autoScrollInterval?: number;
  caption?: string;
  title?: string;
  description?: string;
  author?: string;
  section?: string;
  articleUrl?: string;
}

interface CarouselImage {
  url: string;
  alt?: string;
}

// ImageCarouselItem shape (rendering deferred -- coming soon)
{
  id: 'carousel-1',
  images: [
    { url: 'https://...', alt: 'Description' },
  ],
  autoScrollInterval: 5, // seconds, or null
  caption: 'Photo caption',
  title: 'Headline',
  description: 'Body text',
  author: 'Jane Doe',
  section: 'SPORTS',
  articleUrl: 'https://...',
}

data class VideoCarouselItem(
    val id: String,
    val videos: List<ContentItem>,
    val title: String?,
    val description: String?,
    val author: String?,
    val section: String?,
    val articleUrl: String?
)

interface VideoCarouselItem {
  id: string;
  videos: ContentItem[];
  initialPageIndex?: number;
  title?: string;
  description?: string;
  author?: string;
  section?: string;
  articleUrl?: string;
}

// VideoCarouselItem shape (rendering deferred -- coming soon)
{
  id: 'video-carousel-1',
  videos: [
    { /* ContentItem */ },
    { /* ContentItem */ },
  ],
  title: 'Headline',
  description: 'Body text',
  author: 'Jane Doe',
  section: 'SPORTS',
  articleUrl: 'https://...',
}

data class SurveyItem(
    val id: String,
    val question: String,
    val options: List<SurveyOption>,
    val autoAdvanceDelay: Double?
)

data class SurveyOption(
    val id: String,
    val text: String
)

interface SurveyItem {
  id: string;
  question: string;
  options: SurveyOption[];
  autoAdvanceDelay?: number;
}

interface SurveyOption {
  id: string;
  text: string;
}

// SurveyItem shape (rendering deferred -- coming soon)
{
  id: 'survey-1',
  question: 'How likely are you to recommend us?',
  options: [
    { id: 'opt-1', text: 'Very likely' },
    { id: 'opt-2', text: 'Somewhat likely' },
    { id: 'opt-3', text: 'Not likely' },
  ],
  autoAdvanceDelay: 2, // seconds, or null
}

sealed class FeedItem {
    data class Content(val item: ContentItem) : FeedItem()
    data class AdSlot(val slot: dev.shortkit.sdk.AdSlot) : FeedItem()
    data class ImageCarousel(val item: ImageCarouselItem) : FeedItem()
    data class VideoCarousel(val item: VideoCarouselItem) : FeedItem()
    data class Survey(val item: SurveyItem) : FeedItem()

    val id: String
    val isContent: Boolean
    val isAdSlot: Boolean
    val isImageCarousel: Boolean
    val isVideoCarousel: Boolean
    val isSurvey: Boolean
    val isNonVideo: Boolean
}

type FeedItem =
  | { type: "content"; item: ContentItem }
  | { type: "ad_slot"; item: AdSlot }
  | { type: "image_carousel"; item: ImageCarouselItem }
  | { type: "video_carousel"; item: VideoCarouselItem }
  | { type: "survey"; item: SurveyItem };

// FeedItem discrimination via item.type
// 'content' | 'ad_slot' | 'image_carousel' | 'video_carousel' | 'survey'
{
  type: 'content',
  item: { /* ContentItem */ },
}

when (feedItem) {
    is FeedItem.Content -> {
        val video = feedItem.item
        // video.streamingUrl — HLS manifest
        // video.captionTracks — available subtitles
        // video.customMetadata — app-specific fields
        configureVideoUI(video)
    }
    is FeedItem.ImageCarousel -> {
        val carousel = feedItem.item
        // carousel.images — list of CarouselImage (url + alt)
        // carousel.autoScrollInterval — seconds between pages, or null
        configureCarouselUI(carousel)
    }
    is FeedItem.VideoCarousel -> {
        val videoCarousel = feedItem.item
        // videoCarousel.videos — list of ContentItem (each with playback metadata, captions, etc.)
        // videoCarousel.title, videoCarousel.author, videoCarousel.section — carousel-level metadata
        // SDK handles paging and playback; overlay provides chrome on top.
        configureVideoCarouselUI(videoCarousel)
    }
    is FeedItem.Survey -> {
        val survey = feedItem.item
        // survey.question — the question string
        // survey.options — list of SurveyOption (id + text)
        configureSurveyUI(survey)
    }
    is FeedItem.AdSlot -> {
        // Handled by the ad provider
    }
}

function FeedItemView({ feedItem }: { feedItem: FeedItem }) {
  switch (feedItem.type) {
    case "content":
      return <VideoPlayer item={feedItem.item} />;

    case "image_carousel":
      return <CarouselView item={feedItem.item} />;

    case "video_carousel":
      return <VideoCarouselView item={feedItem.item} />;

    case "survey":
      return <SurveyView item={feedItem.item} />;

    case "ad_slot":
      // Handled by the ad provider
      return null;
  }
}

function handleFeedItem(feedItem) {
  switch (feedItem.type) {
    case 'content':
      renderVideo(feedItem.item);
      break;
    case 'image_carousel':
      renderCarousel(feedItem.item); // coming soon
      break;
    case 'video_carousel':
      renderVideoCarousel(feedItem.item); // coming soon
      break;
    case 'survey':
      renderSurvey(feedItem.item);   // coming soon
      break;
    case 'ad_slot':
      // Handled by the ad provider
      break;
  }
}