X-Api-Key: hv_live_123456789abcdef...

{
  "body": {
    "videos": [
      {
        "id": "vid_AbCdEfGhIjKlMnOp",
        "name": "Product Demo 2024",
        "duration": "5:30",
        "durationSeconds": 330.5,
        "createdAt": "2024-01-15T10:30:00Z",
        "thumbnailUrl": "https://worker.hesedvid.com/t/vid_AbCdEfGhIjKlMnOp/320x180.jpg",
        "description": "Latest product demonstration video",
        "status": "ready",
        "served": "1.2K views",
        "allowPublicAccess": false,
        "videoQuality": "high"
      }
    ],
    "pagination": {
      "total": 156,
      "page": 1,
      "pageSize": 20,
      "totalPages": 8,
      "hasNext": true,
      "hasPrevious": false
    }
  }
}

{
  "body": {
    "id": "vid_AbCdEfGhIjKlMnOp",
    "publicID": "vid_AbCdEfGhIjKlMnOp",
    "name": "Product Demo 2024",
    "duration": "5:30",
    "durationSeconds": 330.5,
    "createdAt": "2024-01-15T10:30:00Z",
    "thumbnailUrl": "https://worker.hesedvid.com/t/vid_AbCdEfGhIjKlMnOp/1280x720.jpg",
    "description": "Latest product demonstration showcasing new features",
    "served": "1.2K views",
    "status": {
      "ready": true,
      "transcoding": false,
      "failed": false
    },

    // Configuration
    "videoQuality": "high",
    "allowPublicAccess": false,
    "maxEdgeLength": 1080,
    "maxFrameRate": 30,
    "pixelFormat": "yuv420p",
    "rateControlMode": "variableBitrate",
    "twoPassVBREncoding": false,
    "compressionRatio": "veryfast",
    "audioCodec": "aac",

    // Encoding ladder
    "encodings": [
      {
        "key": "1080p",
        "shortEdgePixels": 1080,
        "shortEdgeIsWidth": false,
        "videoStreamBitrate": 5000,
        "audioStreamBitrate": 128,
        "audioFormat": "aac",
        "maxFrameRate": 30,
        "pixelFormat": "yuv420p",
        "rateControlMode": "variableBitrate",
        "twoPassVBREncoding": false,
        "compressionRatio": "veryfast"
      },
      {
        "key": "720p",
        "shortEdgePixels": 720,
        "shortEdgeIsWidth": false,
        "videoStreamBitrate": 2500,
        "audioStreamBitrate": 128,
        "audioFormat": "aac",
        "maxFrameRate": 30,
        "pixelFormat": "yuv420p",
        "rateControlMode": "variableBitrate",
        "twoPassVBREncoding": false,
        "compressionRatio": "veryfast"
      },
      {
        "key": "480p",
        "shortEdgePixels": 480,
        "shortEdgeIsWidth": false,
        "videoStreamBitrate": 1000,
        "audioStreamBitrate": 96,
        "audioFormat": "aac",
        "maxFrameRate": 30,
        "pixelFormat": "yuv420p",
        "rateControlMode": "variableBitrate",
        "twoPassVBREncoding": false,
        "compressionRatio": "veryfast"
      }
    ]
  }
}

{
  "reason": "user_request"
}

{
  "body": {
    "status": "deleted",
    "deletedAt": "2024-01-15T11:45:00Z",
    "message": "Video deleted successfully. Content will be removed within 24 hours."
  }
}

graph LR
    A[Uploaded] --> B[Transcoding]
    B --> C[Ready]
    B --> D[Failed]
    C --> E[Deleted]
    D --> E
    D --> F[Retry Processing]
    F --> B

const pollVideoStatus = async (videoID, maxAttempts = 30) => {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const details = await getVideoDetails(videoID);

    if (details.status.ready) {
      console.log('Video is ready!');
      return details;
    } else if (details.status.failed) {
      console.error('Video processing failed');
      return null;
    }

    // Wait before next poll (exponential backoff)
    const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
    await new Promise(resolve => setTimeout(resolve, delay));
  }

  console.log('Status polling timeout');
  return null;
};

// Get only ready videos
const readyVideos = await listVideos({
  filters: { status: 'ready' }
});

// Get videos currently processing
const processingVideos = await listVideos({
  filters: { status: 'transcoding' }
});

// Search for videos containing "demo"
const demoVideos = await listVideos({
  filters: { search: 'demo' }
});

// Case-insensitive search
const productVideos = await listVideos({
  filters: { search: 'product' }
});

// Videos from last month
const lastMonth = new Date();
lastMonth.setMonth(lastMonth.getMonth() - 1);

const recentVideos = await listVideos({
  filters: {
    from: lastMonth.toISOString().split('T')[0],
    to: new Date().toISOString().split('T')[0]
  }
});

// Complex filtering example
const filteredVideos = await listVideos({
  filters: {
    status: 'ready',
    search: 'demo',
    from: '2024-01-01',
    to: '2024-01-31'
  },
  sortBy: 'created_at',
  sortDir: 'desc',
  pageSize: 50
});

const getAllVideos = async (filters = {}) => {
  const allVideos = [];
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const result = await listVideos({
      page,
      pageSize: 100, // Maximum page size
      ...filters
    });

    allVideos.push(...result.videos);
    hasMore = result.pagination.hasNext;
    page++;
  }

  return allVideos;
};

const InfiniteVideoList = () => {
  const [videos, setVideos] = useState([]);
  const [loading, setLoading] = useState(false);
  const [hasMore, setHasMore] = useState(true);
  const [page, setPage] = useState(1);

  const loadMoreVideos = async () => {
    if (loading || !hasMore) return;

    setLoading(true);
    try {
      const result = await listVideos({
        page,
        pageSize: 20
      });

      setVideos(prev => [...prev, ...result.videos]);
      setHasMore(result.pagination.hasNext);
      setPage(prev => prev + 1);
    } catch (error) {
      console.error('Failed to load videos:', error);
    } finally {
      setLoading(false);
    }
  };

  // Load more when user scrolls to bottom
  useEffect(() => {
    const handleScroll = () => {
      if (window.innerHeight + document.documentElement.scrollTop
          >= document.documentElement.offsetHeight - 1000) {
        loadMoreVideos();
      }
    };

    window.addEventListener('scroll', handleScroll);
    return () => window.removeEventListener('scroll', handleScroll);
  }, [page, loading, hasMore]);

  return (
    <div>
      {videos.map(video => (
        <VideoCard key={video.id} video={video} />
      ))}
      {loading && <div>Loading...</div>}
    </div>
  );
};

const handleVideoAPIError = (error, operation) => {
  switch (error.status) {
    case 400:
      console.error(`Bad request for ${operation}:`, error.detail);
      break;
    case 401:
      console.error('Authentication failed - check API key');
      break;
    case 403:
      console.error('Insufficient permissions');
      break;
    case 404:
      console.error('Video or environment not found');
      break;
    case 429:
      console.error('Rate limit exceeded - retry later');
      break;
    case 500:
      console.error('Server error - try again');
      break;
    default:
      console.error(`Unexpected error during ${operation}:`, error);
  }
};

// Usage
try {
  const videos = await listVideos();
} catch (error) {
  handleVideoAPIError(error, 'list videos');
}

const retryOperation = async (operation, maxRetries = 3) => {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;

      // Exponential backoff
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
};

// Usage
const videos = await retryOperation(() => listVideos());

const debugListVideos = async (options = {}) => {
  console.log('Requesting videos with options:', options);

  const startTime = Date.now();
  const result = await listVideos(options);
  const duration = Date.now() - startTime;

  console.log(`Request completed in ${duration}ms`);
  console.log(`Retrieved ${result.videos.length} videos`);
  console.log(`Total available: ${result.pagination.total}`);

  return result;
};