@brigadasos/nadeshiko-sdk 1.0.0 → 1.4.0-dev.6f733b8

package/dist/types.gen.d.ts

@@ -0,0 +1,3976 @@
+export type ClientOptions = {
+    baseUrl: 'http://localhost:5000' | 'https://api.nadeshiko.co' | (string & {});
+};
+/**
+ * Media category type
+ */
+export type Category = 'ANIME' | 'JDRAMA';
+/**
+ * Media information included in search results
+ */
+export type SearchResultMedia = {
+    /**
+     * Unique identifier for the media
+     */
+    mediaId: number;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * URL to the cover image
+     */
+    coverUrl?: string;
+    /**
+     * URL to the banner image
+     */
+    bannerUrl?: string;
+    category: Category;
+};
+/**
+ * Japanese content in search results with optional highlight
+ */
+export type JapaneseSearchContent = {
+    /**
+     * Original Japanese content of the segment
+     */
+    content: string;
+    /**
+     * Japanese content with search terms highlighted
+     */
+    highlight?: string;
+};
+/**
+ * Translation content in search results with optional highlight
+ */
+export type TranslationSearchContent = {
+    /**
+     * Translated content
+     */
+    content?: string;
+    /**
+     * Translated content with search terms highlighted
+     */
+    highlight?: string;
+    /**
+     * Whether the translation was machine-translated
+     */
+    isMachineTranslated: boolean;
+};
+/**
+ * Morphological analysis token
+ */
+export type Morpheme = {
+    /**
+     * Surface form of the token as it appears in the text
+     */
+    surface: string;
+    /**
+     * Reading in katakana
+     */
+    reading: string;
+    /**
+     * Dictionary/base form of the word
+     */
+    baseform: string;
+    /**
+     * Pronunciation in katakana
+     */
+    pronunciation: string;
+    /**
+     * Full part-of-speech tag array
+     */
+    pos: Array<string>;
+    /**
+     * Short part-of-speech label (first element of pos array)
+     */
+    posShort: string;
+    /**
+     * Character offset where the token begins in the original text
+     */
+    begin: number;
+    /**
+     * Character offset where the token ends in the original text
+     */
+    end: number;
+    /**
+     * Pitch accent type — mora position(s) where the pitch drops. 0 = heiban (flat), 1 = atamadaka, 2+ = nakadaka/odaka. Comma-separated in UniDic feature[24]. Null if not available.
+     *
+     */
+    pitchAccentType: Array<number>;
+    /**
+     * Compound accent connection rule from UniDic feature[25]. Values like C1-C5, F1-F6, P1-P13. Null if not available.
+     *
+     */
+    pitchCompoundRule: string;
+    /**
+     * Accent modification rule from UniDic feature[26]. Values like M1, M2, M4. Null if not available.
+     *
+     */
+    pitchModificationRule: string;
+};
+/**
+ * Segment details in search results
+ */
+export type SearchResultSegment = {
+    /**
+     * Segment status
+     */
+    status: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Unique identifier for the segment
+     */
+    uuid: string;
+    /**
+     * Position of the segment within the episode
+     */
+    position: number;
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     */
+    startTime: string;
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     */
+    endTime: string;
+    /**
+     * Episode number where the segment appears
+     */
+    episodeNumber: number;
+    ja: JapaneseSearchContent;
+    en: TranslationSearchContent;
+    es: TranslationSearchContent;
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw: boolean;
+    /**
+     * Morphological analysis of the Japanese content
+     */
+    morphemes?: Array<Morpheme>;
+};
+/**
+ * URLs to media resources for a segment
+ */
+export type SearchResultUrls = {
+    /**
+     * URL to the subtitle image snapshot
+     */
+    imageUrl?: string;
+    /**
+     * URL to the audio clip for this segment
+     */
+    audioUrl?: string;
+    /**
+     * URL to the video clip for this segment
+     */
+    videoUrl?: string;
+};
+/**
+ * A complete search result combining media info, segment details, and URLs
+ */
+export type SearchResult = {
+    /**
+     * Media information for this result
+     */
+    media: SearchResultMedia;
+    /**
+     * Segment details including translations
+     */
+    segment: SearchResultSegment;
+    /**
+     * URLs to media resources (images, audio, video)
+     */
+    urls: SearchResultUrls;
+};
+/**
+ * Pagination metadata for search results
+ */
+export type PaginationInfo = {
+    /**
+     * Number of results returned in this page
+     */
+    pageSize?: number;
+    /**
+     * Whether there are more results after this page
+     */
+    hasMore?: boolean;
+    /**
+     * Estimated total number of matching segments
+     */
+    estimatedTotalHits?: number;
+    /**
+     * Whether estimatedTotalHits is exact or a lower bound
+     */
+    estimatedTotalHitsRelation?: 'EXACT' | 'LOWER_BOUND';
+};
+export type SearchHealthCheckResponse = {
+    results?: Array<SearchResult>;
+    pagination?: PaginationInfo;
+    /**
+     * Cursor for pagination
+     */
+    cursor?: Array<number>;
+};
+/**
+ * Error Response schema for all cases
+ */
+export type Error = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: string;
+    /**
+     * A short, human-readable summary of the problem
+     */
+    title: string;
+    /**
+     * A human-readable explanation specific to this occurrence
+     */
+    detail: string;
+    /**
+     * A URI reference that identifies the problem type (e.g., GitHub issues link)
+     */
+    type?: string;
+    /**
+     * A URI reference that identifies the specific occurrence (e.g., trace ID)
+     */
+    instance?: string;
+    /**
+     * The HTTP status code
+     */
+    status: number;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+export type SearchRequest = {
+    /**
+     * Text or sentence to search (null to search without query)
+     */
+    query?: string;
+    /**
+     * Max amount of entries by response
+     */
+    limit?: number;
+    /**
+     * Unique ID from segment (Useful to get a specific segment)
+     */
+    uuid?: string;
+    /**
+     * Media category filter
+     */
+    category?: Array<Category>;
+    /**
+     * Unique ID from media
+     */
+    mediaId?: number;
+    /**
+     * Array of episodes to get
+     */
+    episode?: Array<number>;
+    /**
+     * Non-negative integer seed for deterministic random sorting
+     */
+    randomSeed?: number;
+    /**
+     * Order by amount of characters
+     */
+    contentSort?: 'ASC' | 'DESC' | 'NONE' | 'TIME_ASC' | 'TIME_DESC' | 'RANDOM';
+    /**
+     * Current page of search
+     */
+    cursor?: Array<number>;
+    /**
+     * Whether to use exact phrase matching
+     */
+    exactMatch?: boolean;
+    /**
+     * Minimum content length
+     */
+    minLength?: number;
+    /**
+     * Maximum content length
+     */
+    maxLength?: number;
+    /**
+     * Media IDs to exclude from results
+     */
+    excludedMediaIds?: Array<number>;
+    /**
+     * Segment status filter
+     */
+    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
+    /**
+     * Media filter with episodes
+     */
+    media?: Array<{
+        mediaId: number;
+        /**
+         * Array of episode numbers
+         */
+        episodes: Array<number>;
+    }>;
+};
+export type SearchResponse = {
+    results?: Array<SearchResult>;
+    pagination?: PaginationInfo;
+    /**
+     * Cursor for pagination
+     */
+    cursor?: Array<number>;
+};
+export type SearchStatsRequest = {
+    /**
+     * Text or sentence to search
+     */
+    query?: string;
+    /**
+     * Media category filter
+     */
+    category?: Array<Category>;
+    /**
+     * Whether to use exact phrase matching
+     */
+    exactMatch?: boolean;
+    /**
+     * Minimum content length
+     */
+    minLength?: number;
+    /**
+     * Maximum content length
+     */
+    maxLength?: number;
+    /**
+     * Media IDs to exclude from results
+     */
+    excludedMediaIds?: Array<number>;
+    /**
+     * Restrict stats to these media IDs (for list-scoped stats)
+     */
+    mediaIds?: Array<number>;
+    /**
+     * Segment status filter
+     */
+    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
+};
+/**
+ * Search result statistics grouped by media
+ */
+export type MediaSearchStats = {
+    /**
+     * Unique identifier for the media
+     */
+    mediaId?: number;
+    category?: Category;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji?: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * Total number of segments found for this media
+     */
+    segmentCount?: number;
+    /**
+     * Mapping of episode numbers to segment hit counts
+     */
+    episodeHits?: {
+        [key: string]: number;
+    };
+};
+/**
+ * Count of entries grouped by media category
+ */
+export type CategoryCount = {
+    category?: Category;
+    /**
+     * Number of entries in this category
+     */
+    count?: number;
+};
+export type SearchStatsResponse = {
+    media?: Array<MediaSearchStats>;
+    categories?: Array<CategoryCount>;
+};
+export type SearchMultipleRequest = {
+    /**
+     * List of words to search for
+     */
+    words: Array<string>;
+    /**
+     * Whether to use exact matching
+     */
+    exactMatch?: boolean;
+};
+/**
+ * Media entry containing word matches
+ */
+export type WordMatchMedia = {
+    /**
+     * Unique identifier for the media
+     */
+    mediaId?: number;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji?: string;
+    /**
+     * Number of times the word appears in this media
+     */
+    matchCount?: number;
+};
+/**
+ * Word matching result with occurrences across media
+ */
+export type WordMatch = {
+    /**
+     * The word that was searched for
+     */
+    word?: string;
+    /**
+     * Indicates whether the word was found in any segment
+     */
+    isMatch?: boolean;
+    /**
+     * Total number of times this word appears across all media
+     */
+    matchCount?: number;
+    /**
+     * List of media containing this word
+     */
+    media?: Array<WordMatchMedia>;
+};
+export type SearchMultipleResponse = {
+    results?: Array<WordMatch>;
+};
+export type SegmentContextRequest = {
+    /**
+     * Media ID
+     */
+    mediaId: number;
+    /**
+     * Episode number
+     */
+    episodeNumber: number;
+    /**
+     * Segment position in the episode
+     */
+    segmentPosition: number;
+    /**
+     * Number of surrounding segments to retrieve
+     */
+    limit?: number;
+};
+export type SegmentContextResponse = {
+    segments: Array<SearchResult>;
+};
+/**
+ * Statistics about media and segments for browse view
+ */
+export type MediaBrowseStats = {
+    /**
+     * Number of media entries matching current search/filter
+     */
+    filteredMediaCount?: number;
+    /**
+     * Number of segments in the filtered media
+     */
+    filteredSegmentCount?: number;
+    /**
+     * Total number of media entries in the entire database
+     */
+    totalMediaCount?: number;
+    /**
+     * Total number of segments in the entire database
+     */
+    totalSegmentCount?: number;
+};
+/**
+ * Summary information about a media entry for browse/list views
+ */
+export type MediaSummary = {
+    /**
+     * Unique identifier for the media
+     */
+    id: number;
+    /**
+     * AniList database ID for the media
+     */
+    anilistId?: number;
+    /**
+     * TMDB (The Movie Database) ID for the media
+     */
+    tmdbId?: number;
+    category?: Category;
+    /**
+     * Timestamp when the media entry was created in the database
+     */
+    createdAt?: string;
+    /**
+     * Timestamp when the media entry was last updated
+     */
+    updatedAt?: number;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji?: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * Format of the media release (e.g., TV, OVA, Movie)
+     */
+    airingFormat?: string;
+    /**
+     * Current airing status (FINISHED, RELEASING)
+     */
+    airingStatus?: string;
+    /**
+     * Start date of the media (YYYY-MM-DD)
+     */
+    startDate?: string;
+    /**
+     * End date of the media (null if unknown) (YYYY-MM-DD)
+     */
+    endDate?: string;
+    /**
+     * Folder name used for storing media files
+     */
+    folderMediaName?: string;
+    /**
+     * List of genres associated with the media
+     */
+    genres?: Array<string>;
+    /**
+     * URL to the cover image
+     */
+    coverUrl?: string;
+    /**
+     * URL to the banner image
+     */
+    bannerUrl?: string;
+    /**
+     * Version identifier for the media entry
+     */
+    version?: string;
+    /**
+     * Total number of subtitle segments available
+     */
+    segmentCount?: number;
+    /**
+     * Total number of episodes available
+     */
+    episodeCount?: number;
+};
+export type MediaBrowseResponse = {
+    stats?: MediaBrowseStats;
+    results?: Array<MediaSummary>;
+    /**
+     * Next cursor for pagination
+     */
+    cursor?: number;
+    /**
+     * Whether more results are available
+     */
+    hasMore?: boolean;
+};
+/**
+ * Japanese voice actor (seiyuu)
+ */
+export type Seiyuu = {
+    /**
+     * AniList staff ID
+     */
+    id: number;
+    /**
+     * Japanese name of the voice actor
+     */
+    nameJa: string;
+    /**
+     * English name of the voice actor
+     */
+    nameEn: string;
+    /**
+     * Profile image URL
+     */
+    imageUrl: string;
+};
+/**
+ * Anime character
+ */
+export type Character = {
+    /**
+     * AniList character ID
+     */
+    id: number;
+    /**
+     * Japanese name of the character
+     */
+    nameJa: string;
+    /**
+     * English name of the character
+     */
+    nameEn: string;
+    /**
+     * Character image URL
+     */
+    imageUrl: string;
+    seiyuu: Seiyuu;
+};
+/**
+ * Character appearing in a media with their role
+ */
+export type MediaCharacter = {
+    character: Character;
+    /**
+     * Character's role in the media
+     */
+    role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+};
+/**
+ * Media collection list
+ */
+export type List = {
+    /**
+     * List ID
+     */
+    id: number;
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list (1 = admin)
+     */
+    userId: number;
+    /**
+     * Visibility of the list
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+};
+/**
+ * Media entry with full metadata
+ */
+export type Media = {
+    /**
+     * Unique identifier for the media
+     */
+    id: number;
+    /**
+     * AniList database ID for the media
+     */
+    anilistId: number;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji: string;
+    /**
+     * English name of the media
+     */
+    nameEn: string;
+    /**
+     * Format of the media release (e.g., TV, OVA, Movie)
+     */
+    airingFormat: string;
+    /**
+     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
+     */
+    airingStatus: string;
+    /**
+     * List of genres associated with the media
+     */
+    genres: Array<string>;
+    /**
+     * Full URL to the cover image
+     */
+    coverUrl: string;
+    /**
+     * Full URL to the banner image
+     */
+    bannerUrl: string;
+    /**
+     * Start date of the media (first airing/release)
+     */
+    startDate: string;
+    /**
+     * End date of the media (last airing/release)
+     */
+    endDate?: string;
+    category: Category;
+    /**
+     * Total number of subtitle segments available
+     */
+    segmentCount?: number;
+    /**
+     * Total number of episodes available
+     */
+    episodeCount?: number;
+    /**
+     * Version identifier for the media entry
+     */
+    version: string;
+    /**
+     * Animation studio that produced the media
+     */
+    studio: string;
+    /**
+     * Airing season label for the media
+     */
+    seasonName: string;
+    /**
+     * Airing year for the media
+     */
+    seasonYear: number;
+    /**
+     * Characters appearing in the media with their voice actors
+     */
+    characters?: Array<MediaCharacter>;
+    /**
+     * Lists that contain this media
+     */
+    lists?: Array<List>;
+};
+export type MediaListResponse = {
+    data: Array<Media>;
+    /**
+     * Next cursor for pagination (undefined if no more results)
+     */
+    cursor?: number;
+    /**
+     * Whether more results are available
+     */
+    hasMoreResults: boolean;
+};
+/**
+ * Character data for creating/updating media
+ */
+export type CharacterInput = {
+    /**
+     * AniList character ID
+     */
+    id: number;
+    /**
+     * Japanese name of the character
+     */
+    nameJa: string;
+    /**
+     * English name of the character
+     */
+    nameEn: string;
+    /**
+     * Character image URL
+     */
+    imageUrl: string;
+    /**
+     * Character's role in the media
+     */
+    role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    /**
+     * AniList staff ID for the Japanese voice actor
+     */
+    seiyuuId: number;
+    /**
+     * Japanese name of the voice actor
+     */
+    seiyuuNameJa: string;
+    /**
+     * English name of the voice actor
+     */
+    seiyuuNameEn: string;
+    /**
+     * Voice actor profile image URL
+     */
+    seiyuuImageUrl: string;
+};
+/**
+ * List data for adding media to a list
+ */
+export type ListInput = {
+    /**
+     * Existing list ID (if adding to existing list)
+     */
+    listId?: number;
+    /**
+     * Name for new list (if creating new list)
+     */
+    listName?: string;
+    /**
+     * Type of list (if creating new list)
+     */
+    listType?: 'SERIES' | 'CUSTOM';
+    /**
+     * Visibility of list (if creating new list)
+     */
+    listVisibility?: 'PUBLIC' | 'PRIVATE';
+    /**
+     * Position/order of media in the list (1-indexed)
+     */
+    position: number;
+};
+/**
+ * Request body for creating a new media entry
+ */
+export type MediaCreateRequest = {
+    /**
+     * AniList database ID for the media
+     */
+    anilistId: number;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji: string;
+    /**
+     * English name of the media
+     */
+    nameEn: string;
+    /**
+     * Format of the media release (e.g., TV, OVA, Movie)
+     */
+    airingFormat: string;
+    /**
+     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
+     */
+    airingStatus: string;
+    /**
+     * List of genres associated with the media
+     */
+    genres: Array<string>;
+    /**
+     * Storage backend for media assets
+     */
+    storage: 'LOCAL' | 'R2';
+    /**
+     * Start date of the media (first airing/release)
+     */
+    startDate: string;
+    /**
+     * End date of the media (last airing/release)
+     */
+    endDate?: string;
+    /**
+     * Media category
+     */
+    category: 'ANIME' | 'JDRAMA';
+    /**
+     * Version of the media-sub-splitter used
+     */
+    version: string;
+    /**
+     * Hash salt used when generating the hash for the related media assets
+     */
+    hashSalt: string;
+    /**
+     * Animation studio that produced the media
+     */
+    studio: string;
+    /**
+     * Airing season label for the media
+     */
+    seasonName: string;
+    /**
+     * Airing year for the media
+     */
+    seasonYear: number;
+    /**
+     * List of characters appearing in the media with their voice actors
+     */
+    characters?: Array<CharacterInput>;
+    /**
+     * Lists to add this media to (e.g., series, franchise)
+     */
+    lists?: Array<ListInput>;
+};
+/**
+ * Request body for updating an existing media entry (all fields optional)
+ */
+export type MediaUpdateRequest = {
+    /**
+     * AniList database ID for the media
+     */
+    anilistId?: number;
+    /**
+     * Original Japanese name of the media
+     */
+    nameJa?: string;
+    /**
+     * Romaji transliteration of the media name
+     */
+    nameRomaji?: string;
+    /**
+     * English name of the media
+     */
+    nameEn?: string;
+    /**
+     * Format of the media release (e.g., TV, OVA, Movie)
+     */
+    airingFormat?: string;
+    /**
+     * Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED)
+     */
+    airingStatus?: string;
+    /**
+     * List of genres associated with the media
+     */
+    genres?: Array<string>;
+    /**
+     * Storage backend for media assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Start date of the media (first airing/release)
+     */
+    startDate?: string;
+    /**
+     * End date of the media (last airing/release)
+     */
+    endDate?: string;
+    /**
+     * Media category
+     */
+    category?: 'ANIME' | 'JDRAMA';
+    /**
+     * Version of the media-sub-splitter used
+     */
+    version?: string;
+    /**
+     * Hash salt used when generating the hash for the related media assets
+     */
+    hashSalt?: string;
+    /**
+     * Animation studio that produced the media
+     */
+    studio?: string;
+    /**
+     * Airing season label for the media
+     */
+    seasonName?: string;
+    /**
+     * Airing year for the media
+     */
+    seasonYear?: number;
+    /**
+     * List of characters appearing in the media with their voice actors
+     */
+    characters?: Array<CharacterInput>;
+    /**
+     * Lists to add this media to (e.g., series, franchise)
+     */
+    lists?: Array<ListInput>;
+    /**
+     * Total number of subtitle segments available
+     */
+    segmentCount?: number;
+};
+export type Episode = {
+    /**
+     * ID of the media this episode belongs to
+     */
+    mediaId: number;
+    /**
+     * Episode number within the media
+     */
+    episodeNumber: number;
+    /**
+     * AniList episode ID for external reference
+     */
+    anilistEpisodeId?: number;
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+    /**
+     * Number of segments in this episode
+     */
+    segmentCount: number;
+};
+export type EpisodeListResponse = {
+    /**
+     * Array of episode objects
+     */
+    data: Array<Episode>;
+    /**
+     * Cursor for pagination (last episode number in current page)
+     */
+    cursor?: number;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+};
+export type EpisodeCreateRequest = {
+    /**
+     * AniList episode ID for external reference
+     */
+    anilistEpisodeId?: number;
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+    /**
+     * Episode number within the media (must be unique for this media)
+     */
+    episodeNumber: number;
+};
+/**
+ * All fields are optional for partial updates
+ */
+export type EpisodeUpdateRequest = {
+    /**
+     * AniList episode ID for external reference
+     */
+    anilistEpisodeId?: number;
+    /**
+     * English title of the episode
+     */
+    titleEn?: string;
+    /**
+     * Romanized title of the episode
+     */
+    titleRomaji?: string;
+    /**
+     * Japanese title of the episode
+     */
+    titleJa?: string;
+    /**
+     * Episode description or synopsis
+     */
+    description?: string;
+    /**
+     * When the episode originally aired
+     */
+    airedAt?: string;
+    /**
+     * Episode duration in seconds
+     */
+    lengthSeconds?: number;
+    /**
+     * URL to episode thumbnail image
+     */
+    thumbnailUrl?: string;
+};
+/**
+ * Japanese content with optional character count
+ */
+export type JapaneseContent = {
+    /**
+     * Original Japanese content
+     */
+    content: string;
+    /**
+     * Number of characters in the Japanese content
+     */
+    characterCount?: number;
+};
+/**
+ * Translation content for a language
+ */
+export type TranslationContent = {
+    /**
+     * Translated content
+     */
+    content?: string;
+    /**
+     * Whether the translation was machine-translated
+     */
+    isMachineTranslated: boolean;
+};
+export type Segment = {
+    /**
+     * Auto-generated segment ID
+     */
+    id: number;
+    /**
+     * Unique identifier for the segment
+     */
+    uuid: string;
+    /**
+     * Position of the segment within the episode
+     */
+    position: number;
+    /**
+     * Segment status
+     */
+    status: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     */
+    startTime: string;
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     */
+    endTime: string;
+    ja: JapaneseContent;
+    en: TranslationContent;
+    es: TranslationContent;
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw: boolean;
+    /**
+     * URL to segment screenshot/image (generated from storage + hashedId)
+     */
+    imageUrl?: string;
+    /**
+     * URL to segment audio file (generated from storage + hashedId)
+     */
+    audioUrl?: string;
+    /**
+     * URL to segment video file (generated from storage + hashedId)
+     */
+    videoUrl?: string;
+    /**
+     * Episode number this segment belongs to
+     */
+    episode: number;
+    /**
+     * Media ID this segment belongs to
+     */
+    mediaId: number;
+    /**
+     * Storage backend for segment assets
+     */
+    storage: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment
+     */
+    hashedId: string;
+    /**
+     * Morphological analysis of the Japanese content
+     */
+    morphemes?: Array<Morpheme>;
+};
+export type SegmentListResponse = {
+    /**
+     * Array of segment objects
+     */
+    data: Array<Segment>;
+    /**
+     * Cursor for pagination (last segment ID in current page)
+     */
+    cursor?: number;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+};
+export type SegmentCreateRequest = {
+    /**
+     * Position of the segment within the episode
+     */
+    position: number;
+    /**
+     * Segment status
+     */
+    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     */
+    startTime: string;
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     */
+    endTime: string;
+    ja: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    es?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    en?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw?: boolean;
+    /**
+     * Storage backend for segment assets
+     */
+    storage: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment (from segment JSON)
+     */
+    hashedId: string;
+};
+/**
+ * All fields are optional for partial updates
+ */
+export type SegmentUpdateRequest = {
+    /**
+     * Position of the segment within the episode
+     */
+    position?: number;
+    /**
+     * Segment status
+     */
+    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment starts
+     */
+    startTime?: string;
+    /**
+     * Timestamp in H:MM:SS.ffffff format indicating when the segment ends
+     */
+    endTime?: string;
+    ja?: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    es?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    en?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    /**
+     * Whether the segment contains NSFW content
+     */
+    isNsfw?: boolean;
+    /**
+     * Storage backend for segment assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment (from segment JSON)
+     */
+    hashedId?: string;
+};
+/**
+ * Character with all media appearances
+ */
+export type CharacterWithMedia = {
+    /**
+     * AniList character ID
+     */
+    id: number;
+    /**
+     * Japanese name of the character
+     */
+    nameJa: string;
+    /**
+     * English name of the character
+     */
+    nameEn: string;
+    /**
+     * Character image URL
+     */
+    imageUrl: string;
+    seiyuu: Seiyuu;
+    /**
+     * All media this character appears in
+     */
+    mediaAppearances: Array<{
+        media?: Media;
+        /**
+         * Character role in this media
+         */
+        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+/**
+ * Seiyuu with all voice acting roles
+ */
+export type SeiyuuWithRoles = {
+    /**
+     * AniList staff ID
+     */
+    id: number;
+    /**
+     * Japanese name of the voice actor
+     */
+    nameJa: string;
+    /**
+     * English name of the voice actor
+     */
+    nameEn: string;
+    /**
+     * Profile image URL
+     */
+    imageUrl: string;
+    /**
+     * All characters voiced by this seiyuu with their media appearances
+     */
+    roles: Array<{
+        character?: Character;
+        media?: Media;
+        /**
+         * Character role in this media
+         */
+        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+export type UserQuotaResponse = {
+    /**
+     * Number of API requests used in the current billing period.
+     */
+    quotaUsed: number;
+    /**
+     * Maximum number of API requests allowed in the current billing period.
+     */
+    quotaLimit: number;
+    /**
+     * Number of API requests remaining in the current billing period.
+     */
+    quotaRemaining: number;
+    /**
+     * Current billing period in YYYYMM format.
+     */
+    periodYyyymm: number;
+    /**
+     * Start of the current billing period (UTC).
+     */
+    periodStart: string;
+    /**
+     * End of the current billing period (UTC).
+     */
+    periodEnd: string;
+};
+export type Report = {
+    /**
+     * Report ID
+     */
+    id: number;
+    /**
+     * Type of the reported entity
+     */
+    reportType: 'SEGMENT' | 'MEDIA';
+    /**
+     * ID of the reported entity (segment UUID or media ID)
+     */
+    targetId: string;
+    /**
+     * Reason for the report
+     */
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
+    /**
+     * Current status of the report
+     */
+    status: 'PENDING' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED';
+    /**
+     * Notes from the admin who reviewed the report
+     */
+    adminNotes?: string;
+    /**
+     * When the report was resolved
+     */
+    resolvedAt?: string;
+    /**
+     * ID of the user who submitted the report
+     */
+    userId: number;
+    /**
+     * ID of the admin who resolved the report
+     */
+    resolvedById?: number;
+    /**
+     * When the report was created
+     */
+    createdAt: string;
+    /**
+     * When the report was last updated
+     */
+    updatedAt?: string;
+};
+export type ReportListResponse = {
+    data: Array<Report>;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+    /**
+     * Cursor for next page
+     */
+    cursor?: number;
+};
+export type CreateReportRequest = {
+    /**
+     * Type of the entity being reported
+     */
+    reportType: 'SEGMENT' | 'MEDIA';
+    /**
+     * ID of the entity being reported (segment UUID or media ID as string)
+     */
+    targetId: string;
+    /**
+     * Reason for the report
+     */
+    reason: 'WRONG_TRANSLATION' | 'WRONG_TIMING' | 'WRONG_AUDIO' | 'NSFW_NOT_TAGGED' | 'DUPLICATE_SEGMENT' | 'WRONG_METADATA' | 'MISSING_EPISODES' | 'WRONG_COVER_IMAGE' | 'INAPPROPRIATE_CONTENT' | 'OTHER';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
+};
+/**
+ * Request body for creating a new standalone list
+ */
+export type ListCreateRequest = {
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list (1 = admin)
+     */
+    userId?: number;
+    /**
+     * Visibility of the list
+     */
+    visibility?: 'PUBLIC' | 'PRIVATE';
+};
+/**
+ * List with all media in order
+ */
+export type ListWithMedia = {
+    /**
+     * List ID
+     */
+    id: number;
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list (1 = admin)
+     */
+    userId: number;
+    /**
+     * Visibility of the list
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+    /**
+     * All media in the list, sorted by position
+     */
+    media: Array<{
+        /**
+         * Position in the list (1-indexed)
+         */
+        position?: number;
+        media?: Media;
+    }>;
+};
+/**
+ * List with saved segments (search result format)
+ */
+export type ListWithSegments = {
+    /**
+     * List ID
+     */
+    id: number;
+    /**
+     * Name of the list
+     */
+    name: string;
+    /**
+     * Type of list
+     */
+    type: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+    /**
+     * User ID who owns the list
+     */
+    userId: number;
+    /**
+     * Visibility of the list
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+    /**
+     * Saved segments with their search result data
+     */
+    segments: Array<{
+        /**
+         * Position in the list
+         */
+        position?: number;
+        /**
+         * User annotation
+         */
+        note?: string;
+        result?: SearchResult;
+    }>;
+    /**
+     * Total number of segments in the list
+     */
+    totalCount: number;
+};
+/**
+ * Request to reindex segments from the database into Elasticsearch
+ */
+export type ReindexRequest = {
+    /**
+     * Array of media to reindex. If not provided, all media will be reindexed.
+     * Each media can optionally specify which episodes to reindex.
+     * If episodes are not specified for a media, all episodes will be reindexed.
+     */
+    media?: Array<{
+        /**
+         * The ID of the media
+         */
+        mediaId: number;
+        /**
+         * Optional array of episode numbers to reindex.
+         * If not provided, all episodes for this media will be reindexed.
+         */
+        episodes?: Array<number>;
+    }>;
+};
+/**
+ * Response from the reindex operation
+ */
+export type ReindexResponse = {
+    /**
+     * Whether the reindex operation completed successfully
+     */
+    success?: boolean;
+    /**
+     * Human-readable message about the reindex operation
+     */
+    message?: string;
+    /**
+     * Statistics about the reindex operation
+     */
+    stats?: {
+        /**
+         * Total number of segments processed
+         */
+        totalSegments?: number;
+        /**
+         * Number of segments successfully indexed
+         */
+        successfulIndexes?: number;
+        /**
+         * Number of segments that failed to index
+         */
+        failedIndexes?: number;
+        /**
+         * Number of media items processed
+         */
+        mediaProcessed?: number;
+    };
+    /**
+     * Array of errors that occurred during reindexing (if any)
+     */
+    errors?: Array<{
+        /**
+         * ID of the segment that failed
+         */
+        segmentId?: number;
+        /**
+         * Error message
+         */
+        error?: string;
+    }>;
+};
+export type AdminReport = Report & {
+    /**
+     * Number of reports for the same target
+     */
+    reportCount: number;
+    /**
+     * Name of the user who submitted this report
+     */
+    reporterName: string;
+};
+export type AdminReportListResponse = {
+    data: Array<AdminReport>;
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+    /**
+     * Cursor for next page
+     */
+    cursor?: number;
+};
+export type UpdateReportRequest = {
+    /**
+     * New status for the report
+     */
+    status?: 'PENDING' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED';
+    /**
+     * Admin notes about the report
+     */
+    adminNotes?: string;
+};
+export type HealthCheckData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/health';
+};
+export type HealthCheckErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type HealthCheckError = HealthCheckErrors[keyof HealthCheckErrors];
+export type HealthCheckResponses = {
+    /**
+     * OK
+     */
+    200: SearchHealthCheckResponse;
+};
+export type HealthCheckResponse = HealthCheckResponses[keyof HealthCheckResponses];
+export type SearchSegmentsData = {
+    body?: SearchRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/segments';
+};
+export type SearchSegmentsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SearchSegmentsError = SearchSegmentsErrors[keyof SearchSegmentsErrors];
+export type SearchSegmentsResponses = {
+    /**
+     * OK
+     */
+    200: SearchResponse;
+};
+export type SearchSegmentsResponse = SearchSegmentsResponses[keyof SearchSegmentsResponses];
+export type GetSearchStatsData = {
+    body?: SearchStatsRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/stats';
+};
+export type GetSearchStatsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetSearchStatsError = GetSearchStatsErrors[keyof GetSearchStatsErrors];
+export type GetSearchStatsResponses = {
+    /**
+     * OK
+     */
+    200: SearchStatsResponse;
+};
+export type GetSearchStatsResponse = GetSearchStatsResponses[keyof GetSearchStatsResponses];
+export type SearchWordsData = {
+    body: SearchMultipleRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/words';
+};
+export type SearchWordsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SearchWordsError = SearchWordsErrors[keyof SearchWordsErrors];
+export type SearchWordsResponses = {
+    /**
+     * OK
+     */
+    200: SearchMultipleResponse;
+};
+export type SearchWordsResponse = SearchWordsResponses[keyof SearchWordsResponses];
+export type GetSegmentContextData = {
+    body: SegmentContextRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/context';
+};
+export type GetSegmentContextErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetSegmentContextError = GetSegmentContextErrors[keyof GetSegmentContextErrors];
+export type GetSegmentContextResponses = {
+    /**
+     * OK
+     */
+    200: SegmentContextResponse;
+};
+export type GetSegmentContextResponse = GetSegmentContextResponses[keyof GetSegmentContextResponses];
+export type BrowseMediaData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of results per page
+         */
+        size?: number;
+        /**
+         * Pagination cursor offset
+         */
+        cursor?: number;
+        /**
+         * Search query for filtering media
+         */
+        query?: string;
+        /**
+         * Filter by media category
+         */
+        type?: 'anime' | 'liveaction' | 'audiobook';
+    };
+    url: '/v1/media/browse';
+};
+export type BrowseMediaErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type BrowseMediaError = BrowseMediaErrors[keyof BrowseMediaErrors];
+export type BrowseMediaResponses = {
+    /**
+     * OK
+     */
+    200: MediaBrowseResponse;
+};
+export type BrowseMediaResponse = BrowseMediaResponses[keyof BrowseMediaResponses];
+export type MediaIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Pagination cursor offset
+         */
+        cursor?: number;
+        /**
+         * Filter by media category
+         */
+        category?: 'ANIME' | 'JDRAMA';
+    };
+    url: '/v1/media';
+};
+export type MediaIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type MediaIndexError = MediaIndexErrors[keyof MediaIndexErrors];
+export type MediaIndexResponses = {
+    /**
+     * OK
+     */
+    200: MediaListResponse;
+};
+export type MediaIndexResponse = MediaIndexResponses[keyof MediaIndexResponses];
+export type MediaCreateData = {
+    body: MediaCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/media';
+};
+export type MediaCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Conflict
+     */
+    409: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type MediaCreateError = MediaCreateErrors[keyof MediaCreateErrors];
+export type MediaCreateResponses = {
+    /**
+     * Created
+     */
+    201: Media;
+};
+export type MediaCreateResponse = MediaCreateResponses[keyof MediaCreateResponses];
+export type MediaDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{id}';
+};
+export type MediaDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type MediaDestroyError = MediaDestroyErrors[keyof MediaDestroyErrors];
+export type MediaDestroyResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+        id?: number;
+    };
+};
+export type MediaDestroyResponse = MediaDestroyResponses[keyof MediaDestroyResponses];
+export type MediaShowData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{id}';
+};
+export type MediaShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type MediaShowError = MediaShowErrors[keyof MediaShowErrors];
+export type MediaShowResponses = {
+    /**
+     * OK
+     */
+    200: Media;
+};
+export type MediaShowResponse = MediaShowResponses[keyof MediaShowResponses];
+export type MediaUpdateData = {
+    body: MediaUpdateRequest;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{id}';
+};
+export type MediaUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type MediaUpdateError = MediaUpdateErrors[keyof MediaUpdateErrors];
+export type MediaUpdateResponses = {
+    /**
+     * OK
+     */
+    200: Media;
+};
+export type MediaUpdateResponse = MediaUpdateResponses[keyof MediaUpdateResponses];
+export type EpisodeIndexData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+    };
+    query?: {
+        /**
+         * Maximum number of episodes to return
+         */
+        size?: number;
+        /**
+         * Episode number to start from (for pagination)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes';
+};
+export type EpisodeIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type EpisodeIndexError = EpisodeIndexErrors[keyof EpisodeIndexErrors];
+export type EpisodeIndexResponses = {
+    /**
+     * Paginated list of episodes
+     */
+    200: EpisodeListResponse;
+};
+export type EpisodeIndexResponse = EpisodeIndexResponses[keyof EpisodeIndexResponses];
+export type EpisodeCreateData = {
+    body: EpisodeCreateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes';
+};
+export type EpisodeCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Conflict
+     */
+    409: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type EpisodeCreateError = EpisodeCreateErrors[keyof EpisodeCreateErrors];
+export type EpisodeCreateResponses = {
+    /**
+     * Single episode response
+     */
+    201: Episode;
+};
+export type EpisodeCreateResponse = EpisodeCreateResponses[keyof EpisodeCreateResponses];
+export type EpisodeDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+};
+export type EpisodeDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type EpisodeDestroyError = EpisodeDestroyErrors[keyof EpisodeDestroyErrors];
+export type EpisodeDestroyResponses = {
+    /**
+     * Episode successfully deleted
+     */
+    204: void;
+};
+export type EpisodeDestroyResponse = EpisodeDestroyResponses[keyof EpisodeDestroyResponses];
+export type EpisodeShowData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+};
+export type EpisodeShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type EpisodeShowError = EpisodeShowErrors[keyof EpisodeShowErrors];
+export type EpisodeShowResponses = {
+    /**
+     * Single episode response
+     */
+    200: Episode;
+};
+export type EpisodeShowResponse = EpisodeShowResponses[keyof EpisodeShowResponses];
+export type EpisodeUpdateData = {
+    body: EpisodeUpdateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}';
+};
+export type EpisodeUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type EpisodeUpdateError = EpisodeUpdateErrors[keyof EpisodeUpdateErrors];
+export type EpisodeUpdateResponses = {
+    /**
+     * Single episode response
+     */
+    200: Episode;
+};
+export type EpisodeUpdateResponse = EpisodeUpdateResponses[keyof EpisodeUpdateResponses];
+export type SegmentIndexData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: {
+        /**
+         * Maximum number of segments to return
+         */
+        size?: number;
+        /**
+         * Segment ID to start from (for pagination)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+};
+export type SegmentIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SegmentIndexError = SegmentIndexErrors[keyof SegmentIndexErrors];
+export type SegmentIndexResponses = {
+    /**
+     * Paginated list of segments
+     */
+    200: SegmentListResponse;
+};
+export type SegmentIndexResponse = SegmentIndexResponses[keyof SegmentIndexResponses];
+export type SegmentCreateData = {
+    body: SegmentCreateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+};
+export type SegmentCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Conflict
+     */
+    409: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SegmentCreateError = SegmentCreateErrors[keyof SegmentCreateErrors];
+export type SegmentCreateResponses = {
+    /**
+     * Single segment response
+     */
+    201: Segment;
+};
+export type SegmentCreateResponse = SegmentCreateResponses[keyof SegmentCreateResponses];
+export type SegmentDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+};
+export type SegmentDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SegmentDestroyError = SegmentDestroyErrors[keyof SegmentDestroyErrors];
+export type SegmentDestroyResponses = {
+    /**
+     * Segment successfully deleted
+     */
+    204: void;
+};
+export type SegmentDestroyResponse = SegmentDestroyResponses[keyof SegmentDestroyResponses];
+export type SegmentShowData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+};
+export type SegmentShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SegmentShowError = SegmentShowErrors[keyof SegmentShowErrors];
+export type SegmentShowResponses = {
+    /**
+     * Single segment response
+     */
+    200: Segment;
+};
+export type SegmentShowResponse = SegmentShowResponses[keyof SegmentShowResponses];
+export type SegmentUpdateData = {
+    body: SegmentUpdateRequest;
+    path: {
+        /**
+         * ID of the media
+         */
+        mediaId: number;
+        /**
+         * Episode number
+         */
+        episodeNumber: number;
+        /**
+         * Segment ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments/{id}';
+};
+export type SegmentUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SegmentUpdateError = SegmentUpdateErrors[keyof SegmentUpdateErrors];
+export type SegmentUpdateResponses = {
+    /**
+     * Single segment response
+     */
+    200: Segment;
+};
+export type SegmentUpdateResponse = SegmentUpdateResponses[keyof SegmentUpdateResponses];
+export type SegmentShowByUuidData = {
+    body?: never;
+    path: {
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/media/segments/{uuid}';
+};
+export type SegmentShowByUuidErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SegmentShowByUuidError = SegmentShowByUuidErrors[keyof SegmentShowByUuidErrors];
+export type SegmentShowByUuidResponses = {
+    200: Segment;
+};
+export type SegmentShowByUuidResponse = SegmentShowByUuidResponses[keyof SegmentShowByUuidResponses];
+export type CharacterShowData = {
+    body?: never;
+    path: {
+        /**
+         * AniList character ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/characters/{id}';
+};
+export type CharacterShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type CharacterShowError = CharacterShowErrors[keyof CharacterShowErrors];
+export type CharacterShowResponses = {
+    /**
+     * OK
+     */
+    200: CharacterWithMedia;
+};
+export type CharacterShowResponse = CharacterShowResponses[keyof CharacterShowResponses];
+export type SeiyuuShowData = {
+    body?: never;
+    path: {
+        /**
+         * AniList staff ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/seiyuu/{id}';
+};
+export type SeiyuuShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type SeiyuuShowError = SeiyuuShowErrors[keyof SeiyuuShowErrors];
+export type SeiyuuShowResponses = {
+    /**
+     * OK
+     */
+    200: SeiyuuWithRoles;
+};
+export type SeiyuuShowResponse = SeiyuuShowResponses[keyof SeiyuuShowResponses];
+export type GetUserQuotaData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/quota';
+};
+export type GetUserQuotaErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetUserQuotaError = GetUserQuotaErrors[keyof GetUserQuotaErrors];
+export type GetUserQuotaResponses = {
+    /**
+     * OK
+     */
+    200: UserQuotaResponse;
+};
+export type GetUserQuotaResponse = GetUserQuotaResponses[keyof GetUserQuotaResponses];
+export type GetUserReportsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (report ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        size?: number;
+        /**
+         * Filter by report status
+         */
+        status?: 'PENDING' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED';
+    };
+    url: '/v1/user/reports';
+};
+export type GetUserReportsErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetUserReportsError = GetUserReportsErrors[keyof GetUserReportsErrors];
+export type GetUserReportsResponses = {
+    /**
+     * OK
+     */
+    200: ReportListResponse;
+};
+export type GetUserReportsResponse = GetUserReportsResponses[keyof GetUserReportsResponses];
+export type CreateReportData = {
+    body: CreateReportRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/user/reports';
+};
+export type CreateReportErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type CreateReportError = CreateReportErrors[keyof CreateReportErrors];
+export type CreateReportResponses = {
+    /**
+     * Report created successfully
+     */
+    201: Report;
+};
+export type CreateReportResponse = CreateReportResponses[keyof CreateReportResponses];
+export type ListIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by visibility
+         */
+        visibility?: 'public' | 'private';
+        /**
+         * Filter by list type
+         */
+        type?: 'SERIES' | 'CUSTOM' | 'SEGMENT';
+        /**
+         * Filter by list owner user ID
+         */
+        userId?: number;
+        /**
+         * Filter lists containing this media ID
+         */
+        mediaId?: number;
+    };
+    url: '/v1/lists';
+};
+export type ListIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListIndexError = ListIndexErrors[keyof ListIndexErrors];
+export type ListIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<List>;
+};
+export type ListIndexResponse = ListIndexResponses[keyof ListIndexResponses];
+export type ListCreateData = {
+    body: ListCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/lists';
+};
+export type ListCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListCreateError = ListCreateErrors[keyof ListCreateErrors];
+export type ListCreateResponses = {
+    /**
+     * Created
+     */
+    201: List;
+};
+export type ListCreateResponse = ListCreateResponses[keyof ListCreateResponses];
+export type ListDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}';
+};
+export type ListDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListDestroyError = ListDestroyErrors[keyof ListDestroyErrors];
+export type ListDestroyResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+        id?: number;
+    };
+};
+export type ListDestroyResponse = ListDestroyResponses[keyof ListDestroyResponses];
+export type ListShowData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}';
+};
+export type ListShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListShowError = ListShowErrors[keyof ListShowErrors];
+export type ListShowResponses = {
+    /**
+     * OK
+     */
+    200: ListWithMedia;
+};
+export type ListShowResponse = ListShowResponses[keyof ListShowResponses];
+export type ListUpdateData = {
+    body: {
+        name?: string;
+        visibility?: 'PUBLIC' | 'PRIVATE';
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}';
+};
+export type ListUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListUpdateError = ListUpdateErrors[keyof ListUpdateErrors];
+export type ListUpdateResponses = {
+    /**
+     * OK
+     */
+    200: List;
+};
+export type ListUpdateResponse = ListUpdateResponses[keyof ListUpdateResponses];
+export type ListAddItemData = {
+    body: {
+        mediaId: number;
+        /**
+         * Position in the list (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/items';
+};
+export type ListAddItemErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Conflict
+     */
+    409: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListAddItemError = ListAddItemErrors[keyof ListAddItemErrors];
+export type ListAddItemResponses = {
+    /**
+     * Created
+     */
+    201: {
+        message?: string;
+    };
+};
+export type ListAddItemResponse = ListAddItemResponses[keyof ListAddItemResponses];
+export type ListRemoveItemData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/items/{mediaId}';
+};
+export type ListRemoveItemErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListRemoveItemError = ListRemoveItemErrors[keyof ListRemoveItemErrors];
+export type ListRemoveItemResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListRemoveItemResponse = ListRemoveItemResponses[keyof ListRemoveItemResponses];
+export type ListUpdateItemData = {
+    body: {
+        /**
+         * New position in the list (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/items/{mediaId}';
+};
+export type ListUpdateItemErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListUpdateItemError = ListUpdateItemErrors[keyof ListUpdateItemErrors];
+export type ListUpdateItemResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListUpdateItemResponse = ListUpdateItemResponses[keyof ListUpdateItemResponses];
+export type ListGetSegmentsData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Page number (1-indexed)
+         */
+        page?: number;
+        /**
+         * Items per page
+         */
+        limit?: number;
+    };
+    url: '/v1/lists/{id}/segments';
+};
+export type ListGetSegmentsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListGetSegmentsError = ListGetSegmentsErrors[keyof ListGetSegmentsErrors];
+export type ListGetSegmentsResponses = {
+    /**
+     * OK
+     */
+    200: ListWithSegments;
+};
+export type ListGetSegmentsResponse = ListGetSegmentsResponses[keyof ListGetSegmentsResponses];
+export type ListAddSegmentData = {
+    body: {
+        /**
+         * UUID of the segment to add
+         */
+        segmentUuid: string;
+        /**
+         * Optional annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/segments';
+};
+export type ListAddSegmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Conflict
+     */
+    409: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListAddSegmentError = ListAddSegmentErrors[keyof ListAddSegmentErrors];
+export type ListAddSegmentResponses = {
+    /**
+     * Created
+     */
+    201: {
+        message?: string;
+    };
+};
+export type ListAddSegmentResponse = ListAddSegmentResponses[keyof ListAddSegmentResponses];
+export type ListRemoveSegmentData = {
+    body?: never;
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/segments/{uuid}';
+};
+export type ListRemoveSegmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListRemoveSegmentError = ListRemoveSegmentErrors[keyof ListRemoveSegmentErrors];
+export type ListRemoveSegmentResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListRemoveSegmentResponse = ListRemoveSegmentResponses[keyof ListRemoveSegmentResponses];
+export type ListUpdateSegmentData = {
+    body: {
+        /**
+         * New position in the list
+         */
+        position?: number;
+        /**
+         * Updated annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * List ID
+         */
+        id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/lists/{id}/segments/{uuid}';
+};
+export type ListUpdateSegmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ListUpdateSegmentError = ListUpdateSegmentErrors[keyof ListUpdateSegmentErrors];
+export type ListUpdateSegmentResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ListUpdateSegmentResponse = ListUpdateSegmentResponses[keyof ListUpdateSegmentResponses];
+export type ReindexElasticsearchData = {
+    body?: ReindexRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/reindex';
+};
+export type ReindexElasticsearchErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type ReindexElasticsearchError = ReindexElasticsearchErrors[keyof ReindexElasticsearchErrors];
+export type ReindexElasticsearchResponses = {
+    /**
+     * Reindex operation completed
+     */
+    200: ReindexResponse;
+};
+export type ReindexElasticsearchResponse = ReindexElasticsearchResponses[keyof ReindexElasticsearchResponses];
+export type GetQueueStatsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/queues/stats';
+};
+export type GetQueueStatsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetQueueStatsError = GetQueueStatsErrors[keyof GetQueueStatsErrors];
+export type GetQueueStatsResponses = {
+    /**
+     * Queue statistics retrieved successfully
+     */
+    200: Array<{
+        queue?: string;
+        /**
+         * Number of jobs currently pending/active
+         */
+        stuckCount?: number;
+        /**
+         * Number of failed jobs
+         */
+        failedCount?: number;
+    }>;
+};
+export type GetQueueStatsResponse = GetQueueStatsResponses[keyof GetQueueStatsResponses];
+export type GetQueueDetailsData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}';
+};
+export type GetQueueDetailsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetQueueDetailsError = GetQueueDetailsErrors[keyof GetQueueDetailsErrors];
+export type GetQueueDetailsResponses = {
+    /**
+     * Queue details retrieved successfully
+     */
+    200: {
+        queue?: string;
+        /**
+         * Current queue size (pending jobs)
+         */
+        size?: number;
+        /**
+         * Total jobs created
+         */
+        created?: number;
+        /**
+         * Total failed jobs
+         */
+        failed?: number;
+        /**
+         * Total completed jobs
+         */
+        complete?: number;
+        /**
+         * Total expired jobs
+         */
+        expired?: number;
+        /**
+         * Total cancelled jobs
+         */
+        cancelled?: number;
+    };
+};
+export type GetQueueDetailsResponse = GetQueueDetailsResponses[keyof GetQueueDetailsResponses];
+export type GetFailedJobsData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}/failed';
+};
+export type GetFailedJobsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetFailedJobsError = GetFailedJobsErrors[keyof GetFailedJobsErrors];
+export type GetFailedJobsResponses = {
+    /**
+     * Failed jobs retrieved successfully
+     */
+    200: Array<{
+        /**
+         * Job ID
+         */
+        id?: string;
+        /**
+         * The segment ID that failed to sync
+         */
+        segmentId?: number;
+        /**
+         * Error message from the last attempt
+         */
+        error?: string;
+        /**
+         * When the job was created
+         */
+        createdOn?: string;
+    }>;
+};
+export type GetFailedJobsResponse = GetFailedJobsResponses[keyof GetFailedJobsResponses];
+export type RetryQueueJobsData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}/retry';
+};
+export type RetryQueueJobsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type RetryQueueJobsError = RetryQueueJobsErrors[keyof RetryQueueJobsErrors];
+export type RetryQueueJobsResponses = {
+    /**
+     * Jobs queued for retry
+     */
+    200: {
+        success?: boolean;
+        /**
+         * Number of jobs queued for retry
+         */
+        retriedCount?: number;
+        message?: string;
+    };
+};
+export type RetryQueueJobsResponse = RetryQueueJobsResponses[keyof RetryQueueJobsResponses];
+export type PurgeFailedJobsData = {
+    body?: never;
+    path: {
+        /**
+         * The name of the queue
+         */
+        queueName: 'es-sync-create' | 'es-sync-update' | 'es-sync-delete';
+    };
+    query?: never;
+    url: '/v1/admin/queues/{queueName}/purge';
+};
+export type PurgeFailedJobsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type PurgeFailedJobsError = PurgeFailedJobsErrors[keyof PurgeFailedJobsErrors];
+export type PurgeFailedJobsResponses = {
+    /**
+     * Failed jobs purged successfully
+     */
+    200: {
+        success?: boolean;
+        /**
+         * Number of failed jobs deleted
+         */
+        purgedCount?: number;
+        message?: string;
+    };
+};
+export type PurgeFailedJobsResponse = PurgeFailedJobsResponses[keyof PurgeFailedJobsResponses];
+export type MorphemeBackfillData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/morpheme-backfill';
+};
+export type MorphemeBackfillResponses = {
+    /**
+     * Backfill completed
+     */
+    200: {
+        success: boolean;
+        message: string;
+        stats: {
+            totalSegments: number;
+            successfulAnalyses: number;
+            failedAnalyses: number;
+        };
+    };
+};
+export type MorphemeBackfillResponse = MorphemeBackfillResponses[keyof MorphemeBackfillResponses];
+export type GetAdminReportsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (report ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        size?: number;
+        /**
+         * Filter by report status
+         */
+        status?: 'PENDING' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED';
+        /**
+         * Filter by report type
+         */
+        reportType?: 'SEGMENT' | 'MEDIA';
+        /**
+         * Filter by target ID
+         */
+        targetId?: string;
+    };
+    url: '/v1/admin/reports';
+};
+export type GetAdminReportsErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type GetAdminReportsError = GetAdminReportsErrors[keyof GetAdminReportsErrors];
+export type GetAdminReportsResponses = {
+    /**
+     * OK
+     */
+    200: AdminReportListResponse;
+};
+export type GetAdminReportsResponse = GetAdminReportsResponses[keyof GetAdminReportsResponses];
+export type UpdateReportData = {
+    body: UpdateReportRequest;
+    path: {
+        /**
+         * Report ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/reports/{id}';
+};
+export type UpdateReportErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error;
+    /**
+     * Unauthorized
+     */
+    401: Error;
+    /**
+     * Forbidden
+     */
+    403: Error;
+    /**
+     * Not Found
+     */
+    404: Error;
+    /**
+     * Too Many Requests
+     */
+    429: Error;
+    /**
+     * Internal Server Error
+     */
+    500: Error;
+};
+export type UpdateReportError = UpdateReportErrors[keyof UpdateReportErrors];
+export type UpdateReportResponses = {
+    /**
+     * Report updated successfully
+     */
+    200: Report;
+};
+export type UpdateReportResponse = UpdateReportResponses[keyof UpdateReportResponses];
+//# sourceMappingURL=types.gen.d.ts.map