Blame for frontend/src/api/endpoints.ts

import { api, apiBlob, del, patch, post, postForm, put, qs, uploadFile } from "./client";
import type {
  AnswerFeedback,
  Artifact,
  ArtifactType,
  BillingStatus,
  CalendarItem,
  ChatMessage,
  ChatSummary,
  PublicInfographicData,
  PublicReportData,
  QuizQuestionType,
  ReportSuggestionKind,
  ReportTemplate,
  MemoryNote,
  Doc,
  DocDetail,
  Job,
  LibraryVoice,
  Notebook,
  NotebookSummary,
  WorkspaceChat,
  Page,
  Platform,
  PostableArtifact,
  Quota,
  ResurfaceItem,
  Settings,
  ShareInfo,
  SocialAccounts,
  Source,
  TopicDetail,
  TopicMap,
  Usage,
  Voice,
  Delivery,
  VoiceDesignInput,
  VoiceDesignPreview,
  VoiceProfileData,
  VoiceState,
  ExtractedTheme,
  LegacyVideo,
  MyTemplate,
  ScriptPreview,
  ScriptScene,
  TemplateGeneration,
  TemplatesResponse,
  VideoCatalog,
  VideoConfig,
  VideoCreateBody,
  VideoFocusSource,
  VideoFocusTopic,
  VideoJobState,
  VideoListItem,
  VideoOptions,
  VideoProject,
  VideoProjectData,
  VideoQuota,
  VideoSavedVoice,
  VideoScene,
  VideoStatus,
  VideoStyleItem,
  VideoVoicesResponse,
} from "./types";

type SourceJob = { source: Source; job: Job };

export const sourcesApi = {
  list: () => api<Source[]>("/api/sources"),
  connect: (url: string) => post<SourceJob>("/api/sources", { url }),
  importUrl: (url: string) => post<SourceJob>("/api/sources/url", { url }),
  importFile: async (file: File) => {
    const { upload_id } = await uploadFile(file);
    return post<SourceJob>("/api/sources/upload", { upload_id });
  },
  sync: (id: string) => post<SourceJob>(`/api/sources/${id}/sync`),
  remove: (id: string) => del<{ ok: true; removed_posts: number }>(`/api/sources/${id}`),
};

export const docsApi = {
  list: (p: { q?: string; source_id?: string; indexed_only?: boolean; limit?: number; offset?: number } = {}) =>
    api<Page<Doc>>(`/api/documents${qs(p)}`),
  get: (id: string) => api<DocDetail>(`/api/documents/${id}`),
  remove: (id: string) => del(`/api/documents/${id}`),
};

export const notebooksApi = {
  list: () => api<NotebookSummary[]>("/api/notebooks"),
  get: (id: string) => api<Notebook>(`/api/notebooks/${id}`),
  create: (title: string, document_ids: string[] = [], description?: string) =>
    post<{ id: string; title: string; added: number }>("/api/notebooks", { title, document_ids, description }),
  /** The "All posts" notebook, created on first use. */
  archive: () => post<{ id: string; title: string }>("/api/notebooks/archive"),
  fromTopic: (topicId: string) => post<{ id: string; title: string }>(`/api/notebooks/from-topic/${topicId}`),
  update: (id: string, body: { title?: string; description?: string }) => patch(`/api/notebooks/${id}`, body),
  remove: (id: string) => del(`/api/notebooks/${id}`),
  addDocs: (id: string, document_ids: string[]) =>
    post<{ added: number }>(`/api/notebooks/${id}/documents`, { document_ids }),
  removeDoc: (id: string, docId: string) => del(`/api/notebooks/${id}/documents/${docId}`),
  artifacts: (id: string) => api<Artifact[]>(`/api/notebooks/${id}/artifacts`),
  chats: (id: string) => api<ChatSummary[]>(`/api/notebooks/${id}/chats`),
  /** Every answered chat in the workspace, newest first. */
  allChats: () => api<WorkspaceChat[]>("/api/notebooks/chats"),
  messages: (chatId: string) => api<ChatMessage[]>(`/api/notebooks/chats/${chatId}/messages`),
  removeChat: (chatId: string) => del(`/api/notebooks/chats/${chatId}`),
  /** Thumbs up or down on an answer. rating null takes it back. */
  rate: (messageId: string, body: { rating: "up" | "down" | null; reasons?: string[]; comment?: string }) =>
    put<{ feedback: AnswerFeedback | null }>(`/api/notebooks/messages/${messageId}/feedback`, body),
};

export type GenerateBody = {
  type: ArtifactType;
  notebook_id?: string;
  document_id?: string;
  /** No notebook or post: use the "All posts" notebook. */
  archive?: boolean;
  format?: "deep_dive" | "brief" | "critique" | "debate";
  /** audio_overview: a single narrator or a two host conversation. */
  hosts?: 1 | 2;
  minutes?: number;
  style?: "audiogram";
  audio_artifact_id?: string;
  /** audio_overview: the two hosts' voices, from the workspace's voices (none: the defaults). */
  host_a?: string;
  host_b?: string;
  slides?: { heading: string; body: string }[];
  parent_id?: string;
  /** mind_map: the posts to chart (none: all in the notebook) and what to centre on. */
  document_ids?: string[];
  focus?: string;
  /** quiz: made from a notebook's posts (notebook_id, document_ids) or from notebook chats (chat_ids). */
  chat_ids?: string[];
  topic?: string;
  count?: "fewer" | "standard" | "more";
  difficulty?: "easy" | "medium" | "hard";
  question_types?: QuizQuestionType[];
  language?: string;
  /** report: a written document or an interactive one, its template, and the instructions the writer is given. */
  report_format?: "document" | "interactive";
  template_id?: string;
  instructions?: string;
  /** infographic: one of the looks, and the kind of layout to lean towards (see components/Infographic.tsx); slide_deck: dark-space or light-space. */
  theme?: string;
  ig_style?: string;
  /** slide_deck: read on its own ("detailed") or shown behind a speaker ("presenter"), and how many slides. */
  deck_format?: "detailed" | "presenter";
  deck_length?: "short" | "default" | "long";
};

export const artifactsApi = {
  list: (p: { type?: string; notebook_id?: string; document_id?: string; status?: string; q?: string;
              limit?: number; offset?: number } = {}) => api<Page<Artifact>>(`/api/artifacts${qs(p)}`),
  get: (id: string) => api<Artifact>(`/api/artifacts/${id}`),
  generate: (body: GenerateBody) => post<Artifact>("/api/artifacts/generate", body),
  update: (id: string, body: { title?: string; content?: Record<string, unknown> }) =>
    patch<Artifact>(`/api/artifacts/${id}`, body),
  remove: (id: string) => del(`/api/artifacts/${id}`),
  /** An infographic drawn as a PNG. */
  image: (id: string, layout: "landscape" | "portrait" = "landscape") => apiBlob(`/api/artifacts/${id}/image${qs({ layout })}`),
  /** Thumbs up or down (null takes it back) on a finished report, quiz, flashcard set or infographic. */
  rate: (id: string, body: { rating: "up" | "down" | null; reasons?: string[]; comment?: string }) =>
    put<{ feedback: AnswerFeedback | null }>(`/api/artifacts/${id}/feedback`, body),
  retry: (id: string) => post<Artifact>(`/api/artifacts/${id}/retry`),
  /** A slide deck as a PDF (exactly as shown) or an editable PowerPoint. */
  slidesFile: (id: string, ext: "pdf" | "pptx") => apiBlob(`/api/artifacts/${id}/slides.${ext}`),
  /** A slide deck's slides as the editor has them, drawn without saving (after a slide or a text box is added,
   * removed, moved or changed to another layout). Returns them as they will be kept. */
  previewDeck: (id: string, slides: EditSlide[]) =>
    post<{ slides: EditSlide[]; slides_html: string[]; slide_slots: string[][] }>(`/api/artifacts/${id}/deck-preview`, { slides }),
  /** The editor's slides kept: the server fits the deck again and returns it. */
  saveDeck: (id: string, slides: EditSlide[]) => put<Artifact>(`/api/artifacts/${id}/deck`, { slides }),
};

/** One slide in the stored shape (backend app/slides/content.py, empty_slide). */
export type EditSlide = {
  layout: string;
  variant: string;
  kicker: string;
  heading: string;
  lead: string;
  points: { term: string; text: string }[];
  left: { label: string; items: string[] };
  right: { label: string; items: string[] };
  stat: { value: string; label: string };
  quote: { text: string; by: string };
  takeaways: string[];
  closing: string;
  notes: string;
  sources: { title?: string; path: string; line_start: number; line_end: number }[];
  shrink?: number;
};

export const jobsApi = {
  active: () => api<Job[]>("/api/jobs?active=1"),
  recent: (kind?: string) => api<Job[]>(`/api/jobs${qs({ kind, limit: 10 })}`),
  get: (id: string) => api<Job>(`/api/jobs/${id}`),
};

export const topicsApi = {
  map: () => api<TopicMap>("/api/topics"),
  get: (id: string) => api<TopicDetail>(`/api/topics/${id}`),
  rebuild: (full = false) => post<Job>(`/api/topics/rebuild${qs({ full })}`),
};

export const voiceApi = {
  get: () => api<VoiceState>("/api/voice"),
  update: (body: {
    profile?: VoiceProfileData;
    host_voices?: Partial<{ host_a: string; host_b: string }>;
    delivery?: Partial<{ host_a: Delivery; host_b: Delivery }>;
  }) => put<VoiceState>("/api/voice", body),
  build: (document_ids: string[]) => post<Job>("/api/voice/build", { document_ids }),
  voices: () => api<Voice[]>("/api/voice/voices"),
  consent: async (files: File[], consent_text: string, remove_background_noise: boolean) => {
    const upload_ids = [];
    for (const f of files) upload_ids.push((await uploadFile(f)).upload_id);
    return post<VoiceState & { job: Job }>("/api/voice/consent", { upload_ids, agreed: true, consent_text, remove_background_noise });
  },
  library: (p: { search?: string; gender?: string; age?: string; accent?: string; language?: string; use_case?: string; page?: number }) =>
    api<{ voices: LibraryVoice[]; has_more: boolean }>(`/api/voice/library${qs(p)}`),
  addFromLibrary: (v: LibraryVoice, use_as?: "host_a" | "host_b") =>
    post<VoiceState & { voice_id: string }>("/api/voice/library/add", {
      public_owner_id: v.public_owner_id,
      voice_id: v.voice_id,
      name: v.name,
      use_as,
    }),
  preview: (voice_id: string, opts: { text?: string; host?: "host_a" | "host_b"; delivery?: Delivery } = {}) =>
    post<{ url: string; seconds: number }>("/api/voice/preview", { voice_id, ...opts }),
  readingScript: () => api<{ title: string; text: string; words: number }>("/api/voice/reading-script"),
  quota: () => api<Quota>("/api/voice/quota"),
  revoke: () => del<VoiceState>("/api/voice/consent"),
  design: (input: VoiceDesignInput) => post<{ description: string; previews: VoiceDesignPreview[] }>("/api/voice/design", input),
  saveDesign: (body: { generated_voice_id: string; name: string; description: string; use_as?: "host_a" | "host_b" }) =>
    post<VoiceState & { voice_id: string }>("/api/voice/design/save", body),
};

export type ItemBody = {
  platform: Platform;
  /** An exact instant (Post now). Scheduled posts send local_time + timezone instead. */
  scheduled_at?: string;
  /** The half hour picked on the user's own clock, "2026-10-07T11:00", read in `timezone` (IANA) by the backend. */
  local_time?: string;
  timezone?: string;
  content: string;
  thread?: string[];
  artifact_id?: string | null;
  /** The Launch Kit the post was written from (tracked, not attached). */
  kit_id?: string | null;
  document_id?: string | null;
  social_account_id?: string | null;
  remind_by_email?: boolean;
  draft?: boolean;
  /** Post now: published (or reminded) in the same request, never left scheduled. */
  publish_now?: boolean;
};

export const launchpadApi = {
  items: (p: { start?: string; end?: string; status?: string } = {}) => api<CalendarItem[]>(`/api/calendar${qs(p)}`),
  create: (body: ItemBody) => post<CalendarItem>("/api/calendar", body),
  update: (id: string, body: Partial<ItemBody> & { status?: "scheduled" | "draft" }) =>
    patch<CalendarItem>(`/api/calendar/${id}`, body),
  remove: (id: string) => del(`/api/calendar/${id}`),
  publishNow: (id: string) => post<CalendarItem>(`/api/calendar/${id}/publish`),
  accounts: () => api<SocialAccounts>("/api/social/accounts"),
  connectBluesky: (handle: string, app_password: string) =>
    post<SocialAccounts>("/api/social/bluesky", { handle, app_password }),
  startOAuth: (platform: "x" | "linkedin") => post<{ url: string }>(`/api/social/${platform}/start`),
  completeOAuth: (ticket: string) => post<SocialAccounts>("/api/social/complete", { ticket }),
  disconnect: (id: string) => del(`/api/social/accounts/${id}`),
  /** What can be attached to a post (finished videos, quote cards, carousels, summaries, launch kits; not audio). */
  postable: (q = "") => api<PostableArtifact[]>(`/api/launchpad/postable${qs({ q: q || undefined })}`),
  /** A file from the user's computer, sent to storage: make it postable (an `upload` in the picker). */
  uploadToPost: async (file: File, duration_s?: number) => {
    const { upload_id } = await uploadFile(file);
    return post<PostableArtifact>("/api/launchpad/uploads", { upload_id, duration_s });
  },
};

export const resurfaceApi = {
  get: () => api<{ evergreen: ResurfaceItem[]; on_this_day: ResurfaceItem[]; unscored: number; total_posts: number }>(
    "/api/resurface",
  ),
  scan: () => post<Job>("/api/resurface/scan"),
};

export type SettingsPatch = {
  name?: string;
  workspace_name?: string;
  training_opt_in?: boolean;
  allow_public_links?: boolean;
  email_unsubscribed?: boolean;
};

export const settingsApi = {
  get: () => api<Settings>("/api/settings"),
  update: (body: SettingsPatch) => patch<Settings>("/api/settings", body),
  usage: () => api<Usage>("/api/settings/usage"),
  /** How many posts a generated thing can read (set by the server's ARTIFACT_MAX_POSTS settings). */
  limits: () => api<{ posts: number; selectable_posts: number }>("/api/settings/limits"),
};

export const memoryApi = {
  list: () => api<{ items: MemoryNote[]; limit: number }>("/api/memory"),
  put: (key: string, value: string) => put<MemoryNote>(`/api/memory/${encodeURIComponent(key)}`, { value }),
  remove: (key: string) => del(`/api/memory/${encodeURIComponent(key)}`),
};

export type BillingCycle = "monthly" | "annual";

export const billingApi = {
  status: () => api<BillingStatus>("/api/billing/status"),
  checkout: (plan: string, cycle: BillingCycle) => post<{ url: string }>("/api/billing/checkout", { plan, cycle }),
  portal: () => post<{ url: string }>("/api/billing/portal"),
  confirm: (sessionId: string) => post<BillingStatus>("/api/billing/confirm", { session_id: sessionId }),
};

function form(fields: Record<string, string | number | boolean | Blob | null | undefined>): FormData {
  const f = new FormData();
  for (const [k, v] of Object.entries(fields)) {
    if (v === undefined || v === null) continue;
    f.append(k, v instanceof Blob ? v : String(v));
  }
  return f;
}

export type ScriptDraft = { title: string; display_text: string; narration_text: string; revision: number;
                            draft_scenes: { id: number; title: string; display_text: string | null; narration_text: string }[] };

/** Videos are made by blog2video; the backend proxies every call. Ids here are our artifact ids. */
export const reportsApi = {
  templates: () => api<{ templates: ReportTemplate[]; interactive: ReportTemplate }>("/api/reports/templates"),
  /** Four AI-written templates for these sources (same source fields as a generate request, plus an optional topic). */
  suggest: (body: Record<string, unknown>) => post<{ templates: ReportTemplate[] }>("/api/reports/suggest", body),
  /** Add a visual after a section: made new, or copied from an artifact you already made. Runs as a job. */
  addBlock: (id: string, body: { kind: ReportSuggestionKind; after_block_id?: string; suggestion_id?: string; brief?: string;
                                 existing_artifact_id?: string; theme?: string }) => post<Artifact>(`/api/reports/${id}/blocks`, body),
  removeBlock: (id: string, blockId: string) => del<Artifact>(`/api/reports/${id}/blocks/${blockId}`),
};

export const shareApi = {
  get: (id: string) => api<ShareInfo>(`/api/artifacts/${id}/share`),
  create: (id: string) => post<ShareInfo>(`/api/artifacts/${id}/share`),
  update: (id: string, show_sources: boolean) => patch<ShareInfo>(`/api/artifacts/${id}/share`, { show_sources }),
  remove: (id: string) => del<ShareInfo>(`/api/artifacts/${id}/share`),
};

/** No sign in needed: what the public sees at a share link. */
export const publicApi = {
  report: (token: string) => api<PublicReportData | PublicInfographicData>(`/api/public/reports/${encodeURIComponent(token)}`),
};

export const videosApi = {
  config: () => api<VideoConfig>("/api/videos/config"),
  quota: () => api<VideoQuota>("/api/videos/quota"),
  catalog: () => api<VideoCatalog>("/api/videos/catalog"),
  list: () => api<VideoListItem[]>("/api/videos"),
  create: (body: VideoCreateBody) => post<Artifact>("/api/videos", body),
  /** Three topics the AI suggests a video from this source could focus on. */
  focusTopics: (body: VideoFocusSource) => post<{ topics: VideoFocusTopic[] }>("/api/videos/focus-topics", body),
  /** Multi-link: one video per link. Items with `error` say where it stopped (usually the allowance ran out). */
  createBatch: (urls: string[], options: VideoOptions) =>
    post<(Artifact | { error: string; url: string })[]>("/api/videos/batch", { ...options, urls }),
  /** Up to 5 documents; blog2video reads them itself. */
  createFromFiles: (files: File[], options: VideoOptions) => {
    const f = new FormData();
    files.forEach((file) => f.append("files", file));
    f.append("options", JSON.stringify(options));
    return postForm<Artifact>("/api/videos/upload", f);
  },
  get: (id: string) => api<VideoProject | LegacyVideo>(`/api/videos/${id}`),
  status: (id: string) => api<VideoStatus>(`/api/videos/${id}/status`),
  remove: (id: string) => del(`/api/videos/${id}`),
  // Script review
  script: (id: string) => api<{ status: string; scenes: ScriptScene[] }>(`/api/videos/${id}/script`),
  narrationPreview: (id: string, sceneId: number, body: ScriptDraft) =>
    post<ScriptPreview>(`/api/videos/${id}/script/scenes/${sceneId}/narration-preview`, body),
  approveScript: (id: string, scenes: (ScriptScene & { source_fingerprint?: string; accepted_ai_instructions?: string[] })[]) =>
    post<unknown>(`/api/videos/${id}/script/approve`, { scenes }),
};

const P = (id: string, path: string) => `/api/videos/${id}/p/${path}`;
export type LayoutSchema = Record<string, { defaults?: Record<string, unknown>; fields?: Record<string, unknown>[] }>;

/** The template's layouts, from blog2video's GET .../layouts. Variants ("news_headline__v2") are visual styles of a base
 * layout: layout_variants maps a base to its variant ids, layout_variant_labels names each ("Broadsheet"). */
export type LayoutInfo = {
  layouts: string[];
  layout_names?: Record<string, string>;
  layout_prop_schema?: LayoutSchema;
  layout_variants?: Record<string, string[]>;
  layout_variant_labels?: Record<string, string>;
};

export type StockClip = { provider: string; id: string; preview_url: string; thumbnail_url: string; download_url: string;
                          width: number; height: number; duration: number; author: string; page_url: string };

/** The editor: blog2video's project endpoints, through our allowlisted proxy. */
export const videoEditApi = {
  project: (id: string) => api<VideoProjectData>(P(id, "")),
  updateProject: (id: string, body: Partial<VideoProjectData>) => patch<VideoProjectData>(P(id, "update-project"), body),
  // Scenes
  updateScene: (id: string, sceneId: number, body: Partial<Pick<VideoScene, "title" | "display_text" | "narration_text" |
    "visual_description" | "duration_seconds" | "extra_hold_seconds" | "remotion_code">>) =>
    put<VideoScene>(P(id, `scenes/${sceneId}`), body),
  deleteScene: (id: string, sceneId: number) => del<unknown>(P(id, `scenes/${sceneId}`)),
  reorderScenes: (id: string, scene_orders: { scene_id: number; order: number }[]) =>
    post<VideoScene[]>(P(id, "scenes/reorder"), { scene_orders }),
  regenerateScene: (id: string, sceneId: number, body: { description?: string; narration_text?: string;
    regenerate_voiceover?: boolean; voiceover_verbatim?: boolean; layout?: string; image?: File }) =>
    postForm<VideoScene>(P(id, `scenes/${sceneId}/regenerate`), form(body)),
  addScene: (id: string, prompt: string, position?: number) => post<VideoJobState>(P(id, "scenes/add"), { prompt, position }),
  addSceneStatus: (id: string) => api<VideoJobState | null>(P(id, "scenes/add-status")),
  // Images
  uploadImage: (id: string, sceneId: number, image: File) => postForm<VideoScene>(P(id, `scenes/${sceneId}/image`), form({ image })),
  generateImage: (id: string, sceneId: number, image_description: string) =>
    // Not saved on the scene: the image comes back for the user to keep (uploadImage) or discard.
    post<{ image_base64: string; refined_prompt: string }>(P(id, `scenes/${sceneId}/generate-image`), { image_description }),
  imageFocus: (id: string, sceneId: number, body: { image_focus_x: number; image_focus_y: number; image_zoom?: number }) =>
    patch<VideoScene>(P(id, `scenes/${sceneId}/image-focus`), body),
  moveImage: (id: string, from_scene_id: number, to_scene_id: number) =>
    post<unknown>(P(id, "images/move"), { from_scene_id, to_scene_id }),
  swapImages: (id: string, first_scene_id: number, second_scene_id: number) =>
    post<unknown>(P(id, "images/swap"), { first_scene_id, second_scene_id }),
  duplicateImage: (id: string, source_scene_id: number, target_scene_id: number) =>
    post<unknown>(P(id, "images/duplicate"), { source_scene_id, target_scene_id }),
  /** Deletes the image or clip from the video for good (files too) and takes it off any scene. */
  /** The template's layouts; layout_prop_schema[layout].defaults holds its default font sizes (meta.json). */
  layouts: (id: string) => api<LayoutInfo>(P(id, "layouts")),
  deleteAsset: (id: string, assetId: number) => del<unknown>(P(id, `assets/${assetId}`)),
  assignImage: (id: string, scene_id: number, asset_id: number) =>
    post<unknown>(P(id, "images/assign-existing"), { scene_id, asset_id }),
  // Stock footage
  searchStock: (id: string, q: string) => api<{ clips: StockClip[] }>(P(id, `stock-footage/search${qs({ q })}`)),
  /** Downloads the clip into the project (a new asset). It is not on the scene until linkStock. */
  useStock: (id: string, sceneId: number, c: StockClip) =>
    post<{ asset_id: number; filename: string }>(P(id, `scenes/${sceneId}/stock-footage`), { provider: c.provider, clip_id: c.id,
      download_url: c.download_url, width: c.width, height: c.height, duration: c.duration, author: c.author,
      page_url: c.page_url }),
  /** Put a clip that is already in the project on a scene (assignedVideo). */
  linkStock: (id: string, scene_id: number, filename: string) =>
    post<unknown>(P(id, "stock-footage/link"), { scene_id, filename }),
  pendingStock: (id: string) => api<{ scenes?: unknown[]; [k: string]: unknown }>(P(id, "stock-footage/pending")),
  approveStock: (id: string) => post<unknown>(P(id, "stock-footage/approve")),
  rejectStock: (id: string) => post<unknown>(P(id, "stock-footage/reject")),
  // Voice, voiceovers, language, template
  uploadVoiceover: (id: string, sceneId: number, audio: File) =>
    postForm<VideoScene>(P(id, `scenes/${sceneId}/voiceover`), form({ audio })),
  deleteVoiceover: (id: string) => post<unknown>(P(id, "delete-voiceover")),
  changeVoice: (id: string, body: { voice_gender?: string; voice_accent?: string; custom_voice_id?: string | null }) => post<VideoJobState>(P(id, "change-voice"), body),
  voiceStatus: (id: string) => api<VideoJobState>(P(id, "voice-change-status")),
  changeLanguage: (id: string, content_language: string) => post<VideoJobState>(P(id, "change-language"), { content_language }),
  languageStatus: (id: string) => api<VideoJobState>(P(id, "language-change-status")),
  changeTemplate: (id: string, template: string) =>
    post<VideoJobState>(P(id, "change-template-regenerate-layouts"), { template }),
  templateStatus: (id: string) => api<VideoJobState>(P(id, "template-change-status")),
  // Refresh the script (keeps narration and voiceovers, rewrites titles and layouts)
  refreshScript: (id: string, user_instruction?: string) => post<VideoJobState>(P(id, "regenerate-script"), { user_instruction }),
  refreshStatus: (id: string) => api<VideoJobState>(P(id, "regenerate-script-status")),
  refreshPreview: (id: string) => api<Record<string, unknown>>(P(id, "regenerate-script/preview")),
  refreshVerify: (id: string) => post<unknown>(P(id, "regenerate-script/verify")),
  refreshRetry: (id: string, user_instruction?: string) =>
    post<VideoJobState>(P(id, "regenerate-script/regenerate"), { user_instruction }),
  // Render, download, frames
  /** force renders again even when an MP4 is already on R2 (blog2video otherwise just returns the old one). */
  render: (id: string, { force = false, resolution = "1080p" }: { force?: boolean; resolution?: string } = {}) =>
    post<VideoJobState>(P(id, `render${qs({ resolution, force_render: force || undefined })}`)),
  renderStatus: (id: string) => api<VideoJobState>(P(id, "render-status")),
  cancelRender: (id: string) => post<unknown>(P(id, "cancel-render")),
  downloadUrl: (id: string) => api<{ url: string }>(P(id, "download-url")),
  still: (id: string, frame: number) => apiBlob(P(id, `render-still${qs({ frame })}`)),
};

export const videoVoicesApi = {
  list: () => api<VideoVoicesResponse>("/api/video-voices"),
  save: (voice_id: string) => post<VideoSavedVoice>("/api/video-voices/saved", { voice_id }),
  unsave: (voice_id: string) => del(`/api/video-voices/saved/${encodeURIComponent(voice_id)}`),
};

export const videoStylesApi = {
  list: () => api<VideoStyleItem[]>("/api/video-styles"),
  aiDraft: (prompt: string) => post<{ name: string; guidance: string }>("/api/video-styles/ai-draft", { prompt }),
  create: (body: { name: string; guidance: string; creation_method: "manual" | "ai"; source_prompt?: string }) =>
    post<VideoStyleItem>("/api/video-styles", body),
  update: (styleId: number, body: { name: string; guidance: string; version: number }) =>
    patch<VideoStyleItem>(`/api/video-styles/${styleId}`, body),
  remove: (styleId: number) => del(`/api/video-styles/${styleId}`),
};

const T = (id: number, path: string) => `/api/video-templates/${id}/p/${path}`;

export const videoTemplatesApi = {
  list: () => api<TemplatesResponse>("/api/video-templates"),
  extractFromUrl: (url: string) => post<ExtractedTheme>("/api/video-templates/extract/url", { url }),
  extractFromPrompt: (prompt: string, name?: string) =>
    post<ExtractedTheme>("/api/video-templates/extract/prompt", { prompt, name }),
  extractFromDoc: (file: File, name: string) => postForm<ExtractedTheme>("/api/video-templates/extract/doc", form({ file, name })),
  create: (body: { name: string; theme: Record<string, unknown>; source_url?: string; logo_urls?: string[];
                   og_image?: string; screenshot_url?: string }) => post<MyTemplate>("/api/video-templates", body),
  generate: (id: number) => post<unknown>(`/api/video-templates/${id}/generate`),
  generationStatus: (id: number) => api<TemplateGeneration>(`/api/video-templates/${id}/generation-status`),
  remove: (id: number) => del(`/api/video-templates/${id}`),
  // Editing
  get: (id: number) => api<Record<string, unknown>>(T(id, "")),
  update: (id: number, body: { name?: string; theme?: Record<string, unknown> }) => put<Record<string, unknown>>(T(id, ""), body),
  uploadLogo: (id: number, file: File) => postForm<unknown>(T(id, "upload-logo"), form({ file })),
  drafts: (id: number) => api<unknown>(T(id, "scene-drafts")),
  applyDraft: (id: number, sceneKey: string) => post<unknown>(T(id, `scenes/${sceneKey}/draft/apply`)),
  discardDraft: (id: number, sceneKey: string) => post<unknown>(T(id, `scenes/${sceneKey}/draft/discard`)),
  fontDefaults: (id: number, body: Record<string, unknown>, sceneKey?: string) =>
    patch<unknown>(T(id, sceneKey ? `scenes/${sceneKey}/font-defaults` : "scenes/font-defaults"), body),
  chart: (id: number, sceneKey: string, body: Record<string, unknown>) => patch<unknown>(T(id, `scenes/${sceneKey}/chart`), body),
  versions: (id: number) => api<unknown>(T(id, "versions")),
  rollback: (id: number, versionId: number) => post<unknown>(T(id, `versions/${versionId}/rollback`)),
  regenerate: (id: number) => post<unknown>(T(id, "regenerate-code")),
  resume: (id: number) => post<unknown>(T(id, "resume-generation")),
  rate: (id: number, body: Record<string, unknown>) => post<unknown>(T(id, "rating"), body),
};