@brigadasos/nadeshiko-sdk 1.3.0 → 1.4.0-dev.28a0384

package/dist/types.gen.d.ts

@@ -0,0 +1,5121 @@
+export type ClientOptions = {
+    baseUrl: 'http://localhost:5000' | 'https://api.nadeshiko.co' | (string & {});
+};
+/**
+ * A media filter entry with optional episode restriction
+ */
+export type MediaFilterItem = {
+    /**
+     * Media ID to filter
+     */
+    mediaId: number;
+    /**
+     * Specific episodes (omit for all episodes)
+     */
+    episodes?: Array<number>;
+};
+/**
+ * Media category type
+ */
+export type Category = 'ANIME' | 'JDRAMA';
+/**
+ * Content rating level for the segment
+ */
+export type ContentRating = 'SAFE' | 'SUGGESTIVE' | 'QUESTIONABLE' | 'EXPLICIT';
+/**
+ * Search filters for narrowing segment results
+ */
+export type SearchFilters = {
+    /**
+     * Media inclusion/exclusion filters
+     */
+    media?: {
+        /**
+         * Include only segments from these media (with optional episode filter)
+         */
+        include?: Array<MediaFilterItem>;
+        /**
+         * Exclude segments from these media (with optional episode filter)
+         */
+        exclude?: Array<MediaFilterItem>;
+    };
+    /**
+     * Media category filter
+     */
+    category?: Array<Category>;
+    /**
+     * Content ratings to include (omit for all ratings)
+     */
+    contentRating?: Array<ContentRating>;
+    /**
+     * Segment status filter
+     */
+    status?: Array<'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG'>;
+    /**
+     * Content character count range filter
+     */
+    segmentLengthChars?: {
+        /**
+         * Minimum content length
+         */
+        min?: number;
+        /**
+         * Maximum content length
+         */
+        max?: number;
+    };
+    /**
+     * Segment audio duration range filter (in milliseconds)
+     */
+    segmentDurationMs?: {
+        /**
+         * Minimum duration in ms
+         */
+        min?: number;
+        /**
+         * Maximum duration in ms
+         */
+        max?: number;
+    };
+};
+/**
+ * Resource to expand in the response includes block
+ */
+export type IncludeExpansion = 'media';
+export type SearchRequest = {
+    /**
+     * What to search for (omit for queryless browse)
+     */
+    query?: {
+        /**
+         * Search expression (supports boolean operators, wildcards, phrase matching)
+         */
+        search?: string;
+        /**
+         * Whether to use exact phrase matching
+         */
+        exactMatch?: boolean;
+    };
+    /**
+     * Max amount of entries by response
+     */
+    limit?: number;
+    /**
+     * Current page of search
+     */
+    cursor?: Array<number>;
+    /**
+     * Sort configuration
+     */
+    sort?: {
+        /**
+         * Sort mode
+         */
+        mode?: 'ASC' | 'DESC' | 'NONE' | 'TIME_ASC' | 'TIME_DESC' | 'RANDOM';
+        /**
+         * Non-negative integer seed for deterministic random sorting (only used when mode is RANDOM)
+         */
+        seed?: number;
+    };
+    filters?: SearchFilters;
+    /**
+     * Resources to expand in the response includes block
+     */
+    include?: Array<IncludeExpansion>;
+};
+/**
+ * Segment with content, optional highlights, and media URLs
+ */
+export type Segment = {
+    /**
+     * 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';
+    /**
+     * Start time of the segment in milliseconds from the beginning of the episode
+     */
+    startTimeMs: number;
+    /**
+     * End time of the segment in milliseconds from the beginning of the episode
+     */
+    endTimeMs: number;
+    contentRating: ContentRating;
+    /**
+     * Episode number this segment belongs to
+     */
+    episode: number;
+    /**
+     * Media ID this segment belongs to
+     */
+    mediaId: number;
+    textJa: {
+        /**
+         * Original Japanese content
+         */
+        content: string;
+        /**
+         * Japanese content with search terms highlighted
+         */
+        highlight?: string;
+    };
+    textEn: {
+        /**
+         * English translation
+         */
+        content: string;
+        /**
+         * Whether the translation was machine-translated
+         */
+        isMachineTranslated: boolean;
+        /**
+         * English content with search terms highlighted
+         */
+        highlight?: string;
+    };
+    textEs: {
+        /**
+         * Spanish translation
+         */
+        content: string;
+        /**
+         * Whether the translation was machine-translated
+         */
+        isMachineTranslated: boolean;
+        /**
+         * Spanish content with search terms highlighted
+         */
+        highlight?: string;
+    };
+    /**
+     * URLs to media resources for this segment
+     */
+    urls: {
+        /**
+         * 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;
+    };
+};
+/**
+ * Map of external IDs keyed by source. Only sources with values are included.
+ */
+export type ExternalId = {
+    /**
+     * AniList ID
+     */
+    anilist?: string;
+    /**
+     * IMDB ID
+     */
+    imdb?: string;
+    /**
+     * TVDB ID
+     */
+    tvdb?: string;
+};
+/**
+ * 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;
+};
+/**
+ * Character appearing in a media with their voice actor and role
+ */
+export type MediaCharacter = {
+    /**
+     * 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's role in the media
+     */
+    role: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+};
+/**
+ * Media entry with full metadata
+ */
+export type Media = {
+    /**
+     * Unique identifier for the media
+     */
+    id: number;
+    externalIds: ExternalId;
+    /**
+     * 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;
+    /**
+     * 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>;
+};
+/**
+ * Pagination metadata for search results
+ */
+export type PaginationInfo = {
+    /**
+     * 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';
+    /**
+     * Cursor for fetching the next page (undefined when hasMore is false)
+     */
+    cursor?: Array<number>;
+};
+export type SearchResponse = {
+    segments?: Array<Segment>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
+    pagination?: PaginationInfo;
+};
+/**
+ * Bad Request error response
+ */
+export type Error400 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'VALIDATION_FAILED' | 'INVALID_JSON' | 'INVALID_REQUEST';
+    /**
+     * 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: 400;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Unauthorized error response
+ */
+export type Error401 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'AUTH_CREDENTIALS_REQUIRED' | 'AUTH_CREDENTIALS_INVALID' | 'AUTH_CREDENTIALS_EXPIRED' | 'EMAIL_NOT_VERIFIED';
+    /**
+     * 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: 401;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Forbidden error response
+ */
+export type Error403 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'ACCESS_DENIED' | 'INSUFFICIENT_PERMISSIONS';
+    /**
+     * 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: 403;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Too Many Requests error response
+ */
+export type Error429 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'RATE_LIMIT_EXCEEDED' | 'QUOTA_EXCEEDED';
+    /**
+     * 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: 429;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Internal Server Error response
+ */
+export type Error500 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'INTERNAL_SERVER_EXCEPTION';
+    /**
+     * 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: 500;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+export type SearchStatsRequest = {
+    /**
+     * What to search for (omit for queryless stats)
+     */
+    query?: {
+        /**
+         * Search expression (supports boolean operators, wildcards, phrase matching)
+         */
+        search?: string;
+        /**
+         * Whether to use exact phrase matching
+         */
+        exactMatch?: boolean;
+    };
+    filters?: SearchFilters;
+    /**
+     * Resources to expand in the response includes block
+     */
+    include?: Array<IncludeExpansion>;
+};
+/**
+ * Search hit statistics for a single media
+ */
+export type MediaSearchStats = {
+    /**
+     * Media identifier (look up full details in includes.media)
+     */
+    mediaId: number;
+    /**
+     * Number of matching segments found in this media
+     */
+    matchCount: 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>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
+};
+export type SearchMultipleRequest = {
+    /**
+     * What to search for
+     */
+    query: {
+        /**
+         * List of words to search for
+         */
+        words: Array<string>;
+        /**
+         * Whether to use exact matching
+         */
+        exactMatch?: boolean;
+    };
+    filters?: SearchFilters;
+    /**
+     * Resources to expand in the response includes block
+     */
+    include?: Array<IncludeExpansion>;
+};
+/**
+ * Media match count entry
+ */
+export type WordMatchMedia = {
+    /**
+     * Media identifier (look up full details in includes.media)
+     */
+    mediaId: number;
+    /**
+     * 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>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
+};
+/**
+ * Resource to expand in media responses
+ */
+export type MediaIncludeExpansion = 'media' | 'media.characters';
+/**
+ * Cursor pagination metadata
+ */
+export type CursorPagination = {
+    /**
+     * Whether more results are available
+     */
+    hasMore: boolean;
+    /**
+     * Cursor for the next page (`null` when `hasMore` is `false`)
+     */
+    cursor: number;
+};
+export type MediaListResponse = {
+    media: Array<Media>;
+    pagination: CursorPagination;
+};
+/**
+ * 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;
+};
+/**
+ * Request body for creating a new media entry
+ */
+export type MediaCreateRequest = {
+    externalIds?: ExternalId;
+    /**
+     * 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;
+    /**
+     * Base path for R2/CDN storage (e.g. "media/21459")
+     */
+    storageBasePath?: string;
+    /**
+     * List of characters appearing in the media with their voice actors
+     */
+    characters?: Array<CharacterInput>;
+};
+/**
+ * Conflict error response
+ */
+export type Error409 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'ACCOUNT_CONFLICT' | 'DUPLICATE_KEY';
+    /**
+     * 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: 409;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Not Found error response
+ */
+export type Error404 = {
+    /**
+     * Specific error code for programmatic handling
+     */
+    code: 'NOT_FOUND';
+    /**
+     * 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: 404;
+    /**
+     * Optional map of field names to their error messages (for validation errors)
+     */
+    errors?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Request body for updating an existing media entry (all fields optional)
+ */
+export type MediaUpdateRequest = {
+    externalIds?: ExternalId;
+    /**
+     * 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;
+    /**
+     * Base path for R2/CDN storage (e.g. "media/21459")
+     */
+    storageBasePath?: string;
+    /**
+     * List of characters appearing in the media with their voice actors
+     */
+    characters?: Array<CharacterInput>;
+    /**
+     * 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;
+    /**
+     * 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
+     */
+    episodes: Array<Episode>;
+    pagination: CursorPagination;
+};
+export type EpisodeCreateRequest = {
+    /**
+     * 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 = {
+    /**
+     * 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;
+};
+export type SegmentCreateRequest = {
+    /**
+     * Position of the segment within the episode
+     */
+    position: number;
+    /**
+     * Segment status
+     */
+    status?: 'DELETED' | 'ACTIVE' | 'SUSPENDED' | 'VERIFIED' | 'INVALID' | 'TOO_LONG';
+    /**
+     * Start time of the segment in milliseconds from the beginning of the episode
+     */
+    startTimeMs: number;
+    /**
+     * End time of the segment in milliseconds from the beginning of the episode
+     */
+    endTimeMs: number;
+    textJa: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    textEs?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    textEn?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    contentRating?: ContentRating;
+    /**
+     * Raw WD Tagger v3 classifier output used to derive content rating
+     */
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * POS tokenization results keyed by engine (sudachi, unidic)
+     */
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Storage backend for segment assets
+     */
+    storage: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment (from segment JSON)
+     */
+    hashedId: string;
+};
+/**
+ * Segment with internal fields (for internal API responses)
+ */
+export type SegmentInternal = Segment & {
+    /**
+     * Storage backend for segment assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment
+     */
+    hashedId?: string;
+    /**
+     * Base path in the storage backend
+     */
+    storageBasePath?: string;
+    /**
+     * Raw WD Tagger v3 classifier output used to derive content rating
+     */
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * POS tokenization results keyed by engine (sudachi, unidic)
+     */
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * 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';
+    /**
+     * Start time of the segment in milliseconds from the beginning of the episode
+     */
+    startTimeMs?: number;
+    /**
+     * End time of the segment in milliseconds from the beginning of the episode
+     */
+    endTimeMs?: number;
+    textJa?: {
+        /**
+         * Original Japanese content of the segment
+         */
+        content?: string;
+    };
+    textEs?: {
+        /**
+         * Spanish translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the Spanish translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    textEn?: {
+        /**
+         * English translation of the segment content
+         */
+        content?: string;
+        /**
+         * Whether the English translation was machine-translated
+         */
+        isMachineTranslated?: boolean;
+    };
+    contentRating?: ContentRating;
+    /**
+     * Raw WD Tagger v3 classifier output used to derive content rating
+     */
+    ratingAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * POS tokenization results keyed by engine (sudachi, unidic)
+     */
+    posAnalysis?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Storage backend for segment assets
+     */
+    storage?: 'LOCAL' | 'R2';
+    /**
+     * Hash identifier for the segment (from segment JSON)
+     */
+    hashedId?: string;
+};
+export type SegmentContextResponse = {
+    segments: Array<Segment>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
+};
+/**
+ * Ordered media series grouping
+ */
+export type Series = {
+    /**
+     * Series ID
+     */
+    id: number;
+    /**
+     * Japanese name of the series
+     */
+    nameJa: string;
+    /**
+     * Romaji name of the series
+     */
+    nameRomaji: string;
+    /**
+     * English name of the series
+     */
+    nameEn: string;
+};
+export type SeriesListResponse = {
+    series: Array<Series>;
+    pagination: CursorPagination;
+};
+/**
+ * Series with ordered media entries
+ */
+export type SeriesWithMedia = {
+    /**
+     * Series ID
+     */
+    id: number;
+    /**
+     * Japanese name of the series
+     */
+    nameJa: string;
+    /**
+     * Romaji name of the series
+     */
+    nameRomaji: string;
+    /**
+     * English name of the series
+     */
+    nameEn: string;
+    /**
+     * All media in the series, sorted by position
+     */
+    media: Array<{
+        /**
+         * Position in the series (1-indexed)
+         */
+        position?: number;
+        media?: Media;
+    }>;
+};
+/**
+ * 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;
+};
+/**
+ * Character with voice actor and all media appearances
+ */
+export type CharacterWithMedia = Character & {
+    seiyuu: Seiyuu;
+    /**
+     * All media this character appears in
+     */
+    mediaAppearances: Array<{
+        media?: Media;
+        /**
+         * Character role in this media
+         */
+        role?: 'MAIN' | 'SUPPORTING' | 'BACKGROUND';
+    }>;
+};
+/**
+ * Seiyuu details with optional character appearances
+ */
+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;
+    /**
+     * Characters voiced by this seiyuu with their media appearances
+     */
+    characters: Array<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 ReportTargetMedia = {
+    /**
+     * Report target type
+     */
+    type: 'MEDIA';
+    /**
+     * Media ID this report targets
+     */
+    mediaId: number;
+};
+export type ReportTargetEpisode = {
+    /**
+     * Report target type
+     */
+    type: 'EPISODE';
+    /**
+     * Media ID this report targets
+     */
+    mediaId: number;
+    /**
+     * Episode number this report targets
+     */
+    episodeNumber: number;
+};
+export type ReportTargetSegment = {
+    /**
+     * Report target type
+     */
+    type: 'SEGMENT';
+    /**
+     * Media ID this report targets
+     */
+    mediaId: number;
+    /**
+     * Episode number containing the segment
+     */
+    episodeNumber?: number;
+    /**
+     * Segment UUID this report targets
+     */
+    segmentUuid: string;
+};
+export type ReportTarget = ({
+    type: 'MEDIA';
+} & ReportTargetMedia) | ({
+    type: 'EPISODE';
+} & ReportTargetEpisode) | ({
+    type: 'SEGMENT';
+} & ReportTargetSegment);
+export type Report = {
+    /**
+     * Report ID
+     */
+    id: number;
+    /**
+     * Who created this report
+     */
+    source: 'USER' | 'AUTO';
+    target: ReportTarget;
+    /**
+     * ID of the auto-check run that created this report (AUTO only)
+     */
+    reviewCheckRunId?: number;
+    /**
+     * 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' | 'LOW_SEGMENT_MEDIA' | 'EMPTY_EPISODES' | 'MISSING_EPISODES_AUTO' | 'BAD_SEGMENT_RATIO' | 'MEDIA_WITH_NO_EPISODES' | 'MISSING_TRANSLATIONS' | 'DB_ES_SYNC_ISSUES' | 'HIGH_REPORT_DENSITY';
+    /**
+     * Optional description with additional details
+     */
+    description?: string;
+    /**
+     * Check-specific metrics (AUTO reports) or null (USER reports)
+     */
+    data?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Current status of the report
+     */
+    status: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+    /**
+     * Notes from the admin who reviewed the report
+     */
+    adminNotes?: string;
+    /**
+     * ID of the user who submitted the report (USER reports only)
+     */
+    userId?: number;
+    /**
+     * When the report was created
+     */
+    createdAt: string;
+    /**
+     * When the report was last updated
+     */
+    updatedAt?: string;
+};
+export type ReportListResponse = {
+    reports: Array<Report>;
+    pagination: CursorPagination;
+};
+export type UserReportTarget = ({
+    type: 'MEDIA';
+} & ReportTargetMedia) | ({
+    type: 'SEGMENT';
+} & ReportTargetSegment);
+export type CreateReportRequest = {
+    target: UserReportTarget;
+    /**
+     * 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;
+};
+export type UserPreferences = {
+    /**
+     * Lab feature opt-in flags keyed by feature key
+     */
+    labs?: {
+        [key: string]: boolean;
+    };
+    /**
+     * Preferred language for media names display
+     */
+    mediaNameLanguage?: 'english' | 'japanese' | 'romaji';
+    /**
+     * Per-category content rating display preferences
+     */
+    contentRatingPreferences?: {
+        suggestive?: 'show' | 'blur' | 'hide';
+        explicit?: 'show' | 'blur' | 'hide';
+    };
+    searchHistory?: {
+        /**
+         * Whether activity tracking is enabled (default true)
+         */
+        enabled?: boolean;
+    };
+    /**
+     * ISO timestamp of when the user last visited the blog page
+     */
+    blogLastVisited?: string;
+    ankiProfiles?: Array<{
+        id: string;
+        name: string;
+        deck?: string;
+        model?: string;
+        fields?: Array<{
+            key: string;
+            value: string;
+        }>;
+        key?: string;
+        serverAddress: string;
+    }>;
+    /**
+     * Media hidden from search results by the user
+     */
+    hiddenMedia?: Array<{
+        mediaId: number;
+        nameEn?: string;
+        nameJa?: string;
+        nameRomaji?: string;
+    }>;
+};
+/**
+ * Type of user activity
+ */
+export type ActivityType = 'SEARCH' | 'ANKI_EXPORT' | 'SEGMENT_PLAY' | 'LIST_ADD_SEGMENT';
+export type UserActivity = {
+    id: number;
+    activityType: ActivityType;
+    segmentUuid?: string;
+    mediaId?: number;
+    searchQuery?: string;
+    createdAt: string;
+};
+/**
+ * User segment collection
+ */
+export type Collection = {
+    /**
+     * Collection ID
+     */
+    id: number;
+    /**
+     * Name of the collection
+     */
+    name: string;
+    /**
+     * User ID who owns the collection
+     */
+    userId: number;
+    /**
+     * Visibility of the collection
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+};
+export type UserExportCollection = Collection & {
+    /**
+     * Segment UUIDs in saved order
+     */
+    segmentUuids: Array<string>;
+};
+/**
+ * User data export payload (identifier-oriented references)
+ */
+export type UserExportResponse = {
+    profile: {
+        id: number;
+        username: string;
+        email: string;
+        createdAt: string;
+    };
+    preferences: UserPreferences;
+    activity: Array<UserActivity>;
+    collections: Array<UserExportCollection>;
+    reports: Array<Report>;
+};
+export type UserLabFeature = {
+    /**
+     * Unique identifier for the lab feature
+     */
+    key: string;
+    /**
+     * Human-readable feature name
+     */
+    name: string;
+    /**
+     * Description of what the feature does
+     */
+    description: string;
+    /**
+     * Whether the feature is globally available
+     */
+    enabled: boolean;
+    /**
+     * Whether the user has opted in to this feature
+     */
+    userEnabled: boolean;
+};
+/**
+ * Paginated collection list response
+ */
+export type CollectionListResponse = {
+    collections: Array<Collection>;
+    pagination: CursorPagination;
+};
+/**
+ * Request body for creating a new collection
+ */
+export type CollectionRequests = {
+    /**
+     * Name of the collection
+     */
+    name: string;
+    /**
+     * Visibility of the collection
+     */
+    visibility?: 'PUBLIC' | 'PRIVATE';
+};
+/**
+ * Collection with saved segments (search result format)
+ */
+export type CollectionWithSegments = {
+    /**
+     * Collection ID
+     */
+    id: number;
+    /**
+     * Name of the collection
+     */
+    name: string;
+    /**
+     * User ID who owns the collection
+     */
+    userId: number;
+    /**
+     * Visibility of the collection
+     */
+    visibility: 'PUBLIC' | 'PRIVATE';
+    /**
+     * Saved segments with their search result data
+     */
+    segments: Array<{
+        /**
+         * Position in the collection
+         */
+        position?: number;
+        /**
+         * User annotation
+         */
+        note?: string;
+        result?: Segment;
+    }>;
+    includes?: {
+        /**
+         * Media objects keyed by mediaId
+         */
+        media?: {
+            [key: string]: Media;
+        };
+    };
+    /**
+     * Total number of segments in the collection
+     */
+    totalCount: number;
+    pagination: CursorPagination;
+};
+/**
+ * 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 = {
+    reports: Array<AdminReport>;
+    pagination: CursorPagination;
+};
+export type UpdateReportRequest = {
+    /**
+     * New status for the report
+     */
+    status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+    /**
+     * Admin notes about the report
+     */
+    adminNotes?: string;
+};
+export type RunReviewResponse = {
+    /**
+     * Category filter used
+     */
+    category: string;
+    checksRun: Array<{
+        /**
+         * Check identifier
+         */
+        checkName: string;
+        /**
+         * Human-readable check name
+         */
+        label: string;
+        /**
+         * Number of reports created
+         */
+        resultCount: number;
+        /**
+         * ID of the created run record
+         */
+        runId: number;
+    }>;
+    /**
+     * Total reports created across all checks
+     */
+    totalReports: number;
+};
+export type ReviewCheck = {
+    /**
+     * Check ID
+     */
+    id: number;
+    /**
+     * Unique check identifier
+     */
+    name: string;
+    /**
+     * Human-readable label
+     */
+    label: string;
+    /**
+     * What this check does
+     */
+    description: string;
+    /**
+     * What level this check operates on
+     */
+    targetType: 'MEDIA' | 'EPISODE';
+    /**
+     * Current threshold configuration
+     */
+    threshold: {
+        [key: string]: unknown;
+    };
+    /**
+     * Whether this check is active
+     */
+    enabled: boolean;
+    /**
+     * Schema for threshold fields (from registry)
+     */
+    thresholdSchema?: Array<{
+        key?: string;
+        label?: string;
+        type?: 'number' | 'boolean';
+        default?: number | boolean;
+        min?: number;
+        max?: number;
+    }>;
+    /**
+     * Latest run info for this check
+     */
+    latestRun?: {
+        id?: number;
+        resultCount?: number;
+        createdAt?: string;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type ReviewCheckRun = {
+    /**
+     * Run ID
+     */
+    id: number;
+    /**
+     * Name of the check that was run
+     */
+    checkName: string;
+    /**
+     * Category filter used (ANIME/JDRAMA) or null for all
+     */
+    category?: string;
+    /**
+     * Number of reports created in this run
+     */
+    resultCount: number;
+    /**
+     * Snapshot of threshold at run time
+     */
+    thresholdUsed: {
+        [key: string]: unknown;
+    };
+    /**
+     * When this run was executed
+     */
+    createdAt: string;
+};
+export type ReviewAllowlist = {
+    /**
+     * Allowlist entry ID
+     */
+    id: number;
+    /**
+     * Name of the check this entry applies to
+     */
+    checkName: string;
+    /**
+     * Media ID to exclude
+     */
+    mediaId: number;
+    /**
+     * Episode number to exclude (null for media-level checks)
+     */
+    episodeNumber?: number;
+    /**
+     * Why this was allowlisted
+     */
+    reason?: string;
+    /**
+     * When this entry was created
+     */
+    createdAt: string;
+};
+export type SearchIndexData = {
+    body?: SearchRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search';
+};
+export type SearchIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchIndexError = SearchIndexErrors[keyof SearchIndexErrors];
+export type SearchIndexResponses = {
+    /**
+     * OK
+     */
+    200: SearchResponse;
+};
+export type SearchIndexResponse = SearchIndexResponses[keyof SearchIndexResponses];
+export type SearchStatsData = {
+    body?: SearchStatsRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/stats';
+};
+export type SearchStatsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchStatsError = SearchStatsErrors[keyof SearchStatsErrors];
+export type SearchStatsResponses = {
+    /**
+     * OK
+     */
+    200: SearchStatsResponse;
+};
+export type SearchStatsResponse2 = SearchStatsResponses[keyof SearchStatsResponses];
+export type SearchWordsData = {
+    body: SearchMultipleRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/search/words';
+};
+export type SearchWordsErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SearchWordsError = SearchWordsErrors[keyof SearchWordsErrors];
+export type SearchWordsResponses = {
+    /**
+     * OK
+     */
+    200: SearchMultipleResponse;
+};
+export type SearchWordsResponse = SearchWordsResponses[keyof SearchWordsResponses];
+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';
+        /**
+         * Search query for filtering media by name
+         */
+        query?: string;
+        /**
+         * Resources to expand in the media response (`media.characters` implies `media`)
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media';
+};
+export type MediaIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Conflict
+     */
+    409: Error409;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type MediaDestroyError = MediaDestroyErrors[keyof MediaDestroyErrors];
+export type MediaDestroyResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type MediaDestroyResponse = MediaDestroyResponses[keyof MediaDestroyResponses];
+export type MediaShowData = {
+    body?: never;
+    path: {
+        /**
+         * Media ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Resources to expand in the media response (`media.characters` implies `media`)
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media/{id}';
+};
+export type MediaShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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
+         */
+        limit?: number;
+        /**
+         * Episode number to start from (for pagination)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes';
+};
+export type EpisodeIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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
+         */
+        limit?: number;
+        /**
+         * Segment ID to start from (for pagination)
+         */
+        cursor?: number;
+    };
+    url: '/v1/media/{mediaId}/episodes/{episodeNumber}/segments';
+};
+export type SegmentIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SegmentIndexError = SegmentIndexErrors[keyof SegmentIndexErrors];
+export type SegmentIndexResponses = {
+    /**
+     * Paginated segment list response
+     */
+    200: {
+        /**
+         * Array of segment objects
+         */
+        segments: Array<Segment>;
+        pagination: CursorPagination;
+    };
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Conflict
+     */
+    409: Error409;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SegmentCreateError = SegmentCreateErrors[keyof SegmentCreateErrors];
+export type SegmentCreateResponses = {
+    /**
+     * Single segment response with internal fields
+     */
+    201: SegmentInternal;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SegmentUpdateError = SegmentUpdateErrors[keyof SegmentUpdateErrors];
+export type SegmentUpdateResponses = {
+    /**
+     * Single segment response with internal fields
+     */
+    200: SegmentInternal;
+};
+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: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SegmentShowByUuidError = SegmentShowByUuidErrors[keyof SegmentShowByUuidErrors];
+export type SegmentShowByUuidResponses = {
+    200: Segment;
+};
+export type SegmentShowByUuidResponse = SegmentShowByUuidResponses[keyof SegmentShowByUuidResponses];
+export type SegmentContextShowData = {
+    body?: never;
+    path: {
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: {
+        /**
+         * Number of segments to return before and after the target
+         */
+        limit?: number;
+        /**
+         * Content ratings to include (omit for all ratings)
+         */
+        contentRating?: Array<ContentRating>;
+        /**
+         * Resources to expand in the response includes block
+         */
+        include?: Array<IncludeExpansion>;
+    };
+    url: '/v1/media/segments/{uuid}/context';
+};
+export type SegmentContextShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SegmentContextShowError = SegmentContextShowErrors[keyof SegmentContextShowErrors];
+export type SegmentContextShowResponses = {
+    /**
+     * OK
+     */
+    200: SegmentContextResponse;
+};
+export type SegmentContextShowResponse = SegmentContextShowResponses[keyof SegmentContextShowResponses];
+export type SeriesIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Pagination cursor offset
+         */
+        cursor?: number;
+        /**
+         * Case-insensitive search across English, Japanese, and Romaji names
+         */
+        query?: string;
+    };
+    url: '/v1/media/series';
+};
+export type SeriesIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesIndexError = SeriesIndexErrors[keyof SeriesIndexErrors];
+export type SeriesIndexResponses = {
+    /**
+     * OK
+     */
+    200: SeriesListResponse;
+};
+export type SeriesIndexResponse = SeriesIndexResponses[keyof SeriesIndexResponses];
+export type SeriesCreateData = {
+    body: {
+        /**
+         * Japanese name of the series
+         */
+        nameJa: string;
+        /**
+         * Romaji name of the series
+         */
+        nameRomaji: string;
+        /**
+         * English name of the series
+         */
+        nameEn: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/media/series';
+};
+export type SeriesCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesCreateError = SeriesCreateErrors[keyof SeriesCreateErrors];
+export type SeriesCreateResponses = {
+    /**
+     * Created
+     */
+    201: Series;
+};
+export type SeriesCreateResponse = SeriesCreateResponses[keyof SeriesCreateResponses];
+export type SeriesDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/series/{id}';
+};
+export type SeriesDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesDestroyError = SeriesDestroyErrors[keyof SeriesDestroyErrors];
+export type SeriesDestroyResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type SeriesDestroyResponse = SeriesDestroyResponses[keyof SeriesDestroyResponses];
+export type SeriesShowData = {
+    body?: never;
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Resources to expand in the series response (`media.characters` implies `media`)
+         */
+        include?: Array<MediaIncludeExpansion>;
+    };
+    url: '/v1/media/series/{id}';
+};
+export type SeriesShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesShowError = SeriesShowErrors[keyof SeriesShowErrors];
+export type SeriesShowResponses = {
+    /**
+     * OK
+     */
+    200: SeriesWithMedia;
+};
+export type SeriesShowResponse = SeriesShowResponses[keyof SeriesShowResponses];
+export type SeriesUpdateData = {
+    body: {
+        /**
+         * Updated Japanese name
+         */
+        nameJa?: string;
+        /**
+         * Updated Romaji name
+         */
+        nameRomaji?: string;
+        /**
+         * Updated English name
+         */
+        nameEn?: string;
+    };
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/series/{id}';
+};
+export type SeriesUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesUpdateError = SeriesUpdateErrors[keyof SeriesUpdateErrors];
+export type SeriesUpdateResponses = {
+    /**
+     * OK
+     */
+    200: Series;
+};
+export type SeriesUpdateResponse = SeriesUpdateResponses[keyof SeriesUpdateResponses];
+export type SeriesAddMediaData = {
+    body: {
+        /**
+         * Media ID to add
+         */
+        mediaId: number;
+        /**
+         * Position in the series (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/series/{id}/media';
+};
+export type SeriesAddMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesAddMediaError = SeriesAddMediaErrors[keyof SeriesAddMediaErrors];
+export type SeriesAddMediaResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type SeriesAddMediaResponse = SeriesAddMediaResponses[keyof SeriesAddMediaResponses];
+export type SeriesRemoveMediaData = {
+    body?: never;
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/media/series/{id}/media/{mediaId}';
+};
+export type SeriesRemoveMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesRemoveMediaError = SeriesRemoveMediaErrors[keyof SeriesRemoveMediaErrors];
+export type SeriesRemoveMediaResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type SeriesRemoveMediaResponse = SeriesRemoveMediaResponses[keyof SeriesRemoveMediaResponses];
+export type SeriesUpdateMediaData = {
+    body: {
+        /**
+         * New position in the series (1-indexed)
+         */
+        position: number;
+    };
+    path: {
+        /**
+         * Series ID
+         */
+        id: number;
+        /**
+         * Media ID
+         */
+        mediaId: number;
+    };
+    query?: never;
+    url: '/v1/media/series/{id}/media/{mediaId}';
+};
+export type SeriesUpdateMediaErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeriesUpdateMediaError = SeriesUpdateMediaErrors[keyof SeriesUpdateMediaErrors];
+export type SeriesUpdateMediaResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type SeriesUpdateMediaResponse = SeriesUpdateMediaResponses[keyof SeriesUpdateMediaResponses];
+export type CharacterShowData = {
+    body?: never;
+    path: {
+        /**
+         * AniList character ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/media/characters/{id}';
+};
+export type CharacterShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+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?: {
+        /**
+         * Resources to expand in the response (`character` is included by default)
+         */
+        include?: Array<'character'>;
+    };
+    url: '/v1/media/seiyuu/{id}';
+};
+export type SeiyuuShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type SeiyuuShowError = SeiyuuShowErrors[keyof SeiyuuShowErrors];
+export type SeiyuuShowResponses = {
+    /**
+     * OK
+     */
+    200: SeiyuuWithRoles;
+};
+export type SeiyuuShowResponse = SeiyuuShowResponses[keyof SeiyuuShowResponses];
+export type UserQuotaShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/quota';
+};
+export type UserQuotaShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserQuotaShowError = UserQuotaShowErrors[keyof UserQuotaShowErrors];
+export type UserQuotaShowResponses = {
+    /**
+     * OK
+     */
+    200: UserQuotaResponse;
+};
+export type UserQuotaShowResponse = UserQuotaShowResponses[keyof UserQuotaShowResponses];
+export type UserReportIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (report ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by report status
+         */
+        status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+    };
+    url: '/v1/user/reports';
+};
+export type UserReportIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserReportIndexError = UserReportIndexErrors[keyof UserReportIndexErrors];
+export type UserReportIndexResponses = {
+    /**
+     * OK
+     */
+    200: ReportListResponse;
+};
+export type UserReportIndexResponse = UserReportIndexResponses[keyof UserReportIndexResponses];
+export type UserReportCreateData = {
+    body: CreateReportRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/user/reports';
+};
+export type UserReportCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserReportCreateError = UserReportCreateErrors[keyof UserReportCreateErrors];
+export type UserReportCreateResponses = {
+    /**
+     * Report created successfully
+     */
+    201: Report;
+};
+export type UserReportCreateResponse = UserReportCreateResponses[keyof UserReportCreateResponses];
+export type UserPreferencesShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/preferences';
+};
+export type UserPreferencesShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserPreferencesShowError = UserPreferencesShowErrors[keyof UserPreferencesShowErrors];
+export type UserPreferencesShowResponses = {
+    /**
+     * OK
+     */
+    200: UserPreferences;
+};
+export type UserPreferencesShowResponse = UserPreferencesShowResponses[keyof UserPreferencesShowResponses];
+export type UserPreferencesUpdateData = {
+    body: UserPreferences;
+    path?: never;
+    query?: never;
+    url: '/v1/user/preferences';
+};
+export type UserPreferencesUpdateErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserPreferencesUpdateError = UserPreferencesUpdateErrors[keyof UserPreferencesUpdateErrors];
+export type UserPreferencesUpdateResponses = {
+    /**
+     * OK
+     */
+    200: UserPreferences;
+};
+export type UserPreferencesUpdateResponse = UserPreferencesUpdateResponses[keyof UserPreferencesUpdateResponses];
+export type UserActivityDestroyData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only clear activities of this type
+         */
+        activityType?: ActivityType;
+    };
+    url: '/v1/user/activity';
+};
+export type UserActivityDestroyErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityDestroyError = UserActivityDestroyErrors[keyof UserActivityDestroyErrors];
+export type UserActivityDestroyResponses = {
+    /**
+     * OK
+     */
+    200: {
+        message: string;
+        deletedCount: number;
+    };
+};
+export type UserActivityDestroyResponse = UserActivityDestroyResponses[keyof UserActivityDestroyResponses];
+export type UserActivityIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (activity ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by activity type
+         */
+        activityType?: ActivityType;
+        /**
+         * Filter activities to a specific date (YYYY-MM-DD)
+         */
+        date?: string;
+    };
+    url: '/v1/user/activity';
+};
+export type UserActivityIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityIndexError = UserActivityIndexErrors[keyof UserActivityIndexErrors];
+export type UserActivityIndexResponses = {
+    /**
+     * OK
+     */
+    200: {
+        activities: Array<UserActivity>;
+        pagination: CursorPagination;
+    };
+};
+export type UserActivityIndexResponse = UserActivityIndexResponses[keyof UserActivityIndexResponses];
+export type UserActivityHeatmapShowData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of days to include in the heatmap
+         */
+        days?: number;
+        /**
+         * Filter by activity type
+         */
+        activityType?: ActivityType;
+    };
+    url: '/v1/user/activity/heatmap';
+};
+export type UserActivityHeatmapShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityHeatmapShowError = UserActivityHeatmapShowErrors[keyof UserActivityHeatmapShowErrors];
+export type UserActivityHeatmapShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        /**
+         * Map of YYYY-MM-DD date strings to activity counts
+         */
+        counts: {
+            [key: string]: number;
+        };
+    };
+};
+export type UserActivityHeatmapShowResponse = UserActivityHeatmapShowResponses[keyof UserActivityHeatmapShowResponses];
+export type UserActivityStatsShowData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Only count activities from this date onward (YYYY-MM-DD)
+         */
+        since?: string;
+    };
+    url: '/v1/user/activity/stats';
+};
+export type UserActivityStatsShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserActivityStatsShowError = UserActivityStatsShowErrors[keyof UserActivityStatsShowErrors];
+export type UserActivityStatsShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        totalSearches: number;
+        totalExports: number;
+        totalPlays: number;
+        totalListAdds: number;
+        /**
+         * Consecutive days with at least one activity
+         */
+        streakDays: number;
+        topMedia: Array<{
+            mediaId: number;
+            count: number;
+        }>;
+    };
+};
+export type UserActivityStatsShowResponse = UserActivityStatsShowResponses[keyof UserActivityStatsShowResponses];
+export type UserExportShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/export';
+};
+export type UserExportShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserExportShowError = UserExportShowErrors[keyof UserExportShowErrors];
+export type UserExportShowResponses = {
+    /**
+     * OK
+     */
+    200: UserExportResponse;
+};
+export type UserExportShowResponse = UserExportShowResponses[keyof UserExportShowResponses];
+export type UserLabsIndexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/labs';
+};
+export type UserLabsIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type UserLabsIndexError = UserLabsIndexErrors[keyof UserLabsIndexErrors];
+export type UserLabsIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<UserLabFeature>;
+};
+export type UserLabsIndexResponse = UserLabsIndexResponses[keyof UserLabsIndexResponses];
+export type CollectionIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by visibility
+         */
+        visibility?: 'public' | 'private';
+        /**
+         * Cursor offset for pagination
+         */
+        cursor?: number;
+        /**
+         * Page number (1-indexed)
+         *
+         * @deprecated
+         */
+        page?: number;
+        /**
+         * Items per page
+         */
+        limit?: number;
+    };
+    url: '/v1/collections';
+};
+export type CollectionIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionIndexError = CollectionIndexErrors[keyof CollectionIndexErrors];
+export type CollectionIndexResponses = {
+    /**
+     * OK
+     */
+    200: CollectionListResponse;
+};
+export type CollectionIndexResponse = CollectionIndexResponses[keyof CollectionIndexResponses];
+export type CollectionCreateData = {
+    body: CollectionRequests;
+    path?: never;
+    query?: never;
+    url: '/v1/collections';
+};
+export type CollectionCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionCreateError = CollectionCreateErrors[keyof CollectionCreateErrors];
+export type CollectionCreateResponses = {
+    /**
+     * Created
+     */
+    201: Collection;
+};
+export type CollectionCreateResponse = CollectionCreateResponses[keyof CollectionCreateResponses];
+export type CollectionDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/collections/{id}';
+};
+export type CollectionDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionDestroyError = CollectionDestroyErrors[keyof CollectionDestroyErrors];
+export type CollectionDestroyResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type CollectionDestroyResponse = CollectionDestroyResponses[keyof CollectionDestroyResponses];
+export type CollectionShowData = {
+    body?: never;
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * Cursor offset for paginated segments
+         */
+        cursor?: number;
+        /**
+         * Page number (1-indexed)
+         *
+         * @deprecated
+         */
+        page?: number;
+        /**
+         * Items per page
+         */
+        limit?: number;
+    };
+    url: '/v1/collections/{id}';
+};
+export type CollectionShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionShowError = CollectionShowErrors[keyof CollectionShowErrors];
+export type CollectionShowResponses = {
+    /**
+     * OK
+     */
+    200: CollectionWithSegments;
+};
+export type CollectionShowResponse = CollectionShowResponses[keyof CollectionShowResponses];
+export type CollectionUpdateData = {
+    body: {
+        name?: string;
+        visibility?: 'PUBLIC' | 'PRIVATE';
+    };
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/collections/{id}';
+};
+export type CollectionUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionUpdateError = CollectionUpdateErrors[keyof CollectionUpdateErrors];
+export type CollectionUpdateResponses = {
+    /**
+     * OK
+     */
+    200: Collection;
+};
+export type CollectionUpdateResponse = CollectionUpdateResponses[keyof CollectionUpdateResponses];
+export type CollectionAddSegmentData = {
+    body: {
+        /**
+         * UUID of the segment to add
+         */
+        segmentUuid: string;
+        /**
+         * Optional annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/collections/{id}/segments';
+};
+export type CollectionAddSegmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionAddSegmentError = CollectionAddSegmentErrors[keyof CollectionAddSegmentErrors];
+export type CollectionAddSegmentResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type CollectionAddSegmentResponse = CollectionAddSegmentResponses[keyof CollectionAddSegmentResponses];
+export type CollectionRemoveSegmentData = {
+    body?: never;
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/collections/{id}/segments/{uuid}';
+};
+export type CollectionRemoveSegmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionRemoveSegmentError = CollectionRemoveSegmentErrors[keyof CollectionRemoveSegmentErrors];
+export type CollectionRemoveSegmentResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type CollectionRemoveSegmentResponse = CollectionRemoveSegmentResponses[keyof CollectionRemoveSegmentResponses];
+export type CollectionUpdateSegmentData = {
+    body: {
+        /**
+         * New position in the collection
+         */
+        position?: number;
+        /**
+         * Updated annotation
+         */
+        note?: string;
+    };
+    path: {
+        /**
+         * Collection ID
+         */
+        id: number;
+        /**
+         * Segment UUID
+         */
+        uuid: string;
+    };
+    query?: never;
+    url: '/v1/collections/{id}/segments/{uuid}';
+};
+export type CollectionUpdateSegmentErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type CollectionUpdateSegmentError = CollectionUpdateSegmentErrors[keyof CollectionUpdateSegmentErrors];
+export type CollectionUpdateSegmentResponses = {
+    /**
+     * No Content
+     */
+    204: void;
+};
+export type CollectionUpdateSegmentResponse = CollectionUpdateSegmentResponses[keyof CollectionUpdateSegmentResponses];
+export type AdminDashboardShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/dashboard';
+};
+export type AdminDashboardShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminDashboardShowError = AdminDashboardShowErrors[keyof AdminDashboardShowErrors];
+export type AdminDashboardShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        media: {
+            totalMedia: number;
+            totalEpisodes: number;
+            totalSegments: number;
+            totalCharacters: number;
+            totalSeiyuu: number;
+        };
+        users: {
+            totalUsers: number;
+            /**
+             * Users registered in the last 30 days
+             */
+            recentlyRegisteredCount: number;
+            /**
+             * Users active in the last 30 days
+             */
+            recentlyActiveCount: number;
+        };
+        activity: {
+            totalSearches: number;
+            totalExports: number;
+            totalPlays: number;
+            totalCollectionAdds: number;
+            /**
+             * Unique users who searched in the last 7 days
+             */
+            activeSearchers7d: number;
+            topQueries7d: Array<{
+                query: string;
+                count: number;
+            }>;
+            dailyActivity30d: Array<{
+                date: string;
+                count: number;
+            }>;
+        };
+        system: {
+            status: 'healthy' | 'degraded';
+            app: {
+                version: string;
+            };
+            elasticsearch: {
+                status: 'connected' | 'disconnected';
+                version?: string;
+                clusterName?: string;
+                clusterStatus?: string;
+                indexName?: string;
+                documentCount?: number;
+            };
+            database: {
+                status: 'connected' | 'disconnected';
+                version?: string;
+            };
+            queues: Array<{
+                queue: string;
+                stuckCount: number;
+                failedCount: number;
+            }>;
+        };
+    };
+};
+export type AdminDashboardShowResponse = AdminDashboardShowResponses[keyof AdminDashboardShowResponses];
+export type AdminHealthShowData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/health';
+};
+export type AdminHealthShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminHealthShowError = AdminHealthShowErrors[keyof AdminHealthShowErrors];
+export type AdminHealthShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        /**
+         * Overall system status
+         */
+        status: 'healthy' | 'degraded';
+        app: {
+            /**
+             * API version from OpenAPI spec
+             */
+            version: string;
+        };
+        elasticsearch: {
+            status: 'connected' | 'disconnected';
+            version?: string;
+            clusterName?: string;
+            /**
+             * ES cluster health (green, yellow, red)
+             */
+            clusterStatus?: string;
+            indexName?: string;
+            documentCount?: number;
+        };
+        database: {
+            status: 'connected' | 'disconnected';
+            version?: string;
+        };
+    };
+};
+export type AdminHealthShowResponse = AdminHealthShowResponses[keyof AdminHealthShowResponses];
+export type AdminReindexCreateData = {
+    body?: ReindexRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/reindex';
+};
+export type AdminReindexCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReindexCreateError = AdminReindexCreateErrors[keyof AdminReindexCreateErrors];
+export type AdminReindexCreateResponses = {
+    /**
+     * Reindex operation completed
+     */
+    200: ReindexResponse;
+};
+export type AdminReindexCreateResponse = AdminReindexCreateResponses[keyof AdminReindexCreateResponses];
+export type AdminQueueStatsIndexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/queues/stats';
+};
+export type AdminQueueStatsIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueStatsIndexError = AdminQueueStatsIndexErrors[keyof AdminQueueStatsIndexErrors];
+export type AdminQueueStatsIndexResponses = {
+    /**
+     * Queue statistics retrieved successfully
+     */
+    200: Array<{
+        queue?: string;
+        /**
+         * Number of jobs currently pending/active
+         */
+        stuckCount?: number;
+        /**
+         * Number of failed jobs
+         */
+        failedCount?: number;
+    }>;
+};
+export type AdminQueueStatsIndexResponse = AdminQueueStatsIndexResponses[keyof AdminQueueStatsIndexResponses];
+export type AdminQueueShowData = {
+    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 AdminQueueShowErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueShowError = AdminQueueShowErrors[keyof AdminQueueShowErrors];
+export type AdminQueueShowResponses = {
+    /**
+     * Queue details retrieved successfully
+     */
+    200: {
+        queue: string;
+        stats: {
+            /**
+             * Jobs scheduled for future execution (`start_after > now()`)
+             */
+            deferred: number;
+            /**
+             * Jobs currently queued and waiting to be processed
+             */
+            queued: number;
+            /**
+             * Jobs currently being processed
+             */
+            active: number;
+            /**
+             * Total jobs currently stored in the queue table
+             */
+            total: number;
+        };
+        metadata: {
+            policy: string;
+            partition: boolean;
+            deadLetter?: string;
+            warningQueueSize?: number;
+            retryLimit?: number;
+            /**
+             * Initial retry delay in seconds
+             */
+            retryDelay?: number;
+            retryBackoff?: boolean;
+            retryDelayMax?: number;
+            expireInSeconds?: number;
+            retentionSeconds?: number;
+            deleteAfterSeconds?: number;
+            createdOn: string;
+            updatedOn: string;
+            singletonsActive: Array<string>;
+            table: string;
+        };
+    };
+};
+export type AdminQueueShowResponse = AdminQueueShowResponses[keyof AdminQueueShowResponses];
+export type AdminQueueFailedIndexData = {
+    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 AdminQueueFailedIndexErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueFailedIndexError = AdminQueueFailedIndexErrors[keyof AdminQueueFailedIndexErrors];
+export type AdminQueueFailedIndexResponses = {
+    /**
+     * 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 AdminQueueFailedIndexResponse = AdminQueueFailedIndexResponses[keyof AdminQueueFailedIndexResponses];
+export type AdminQueueRetryCreateData = {
+    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 AdminQueueRetryCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueRetryCreateError = AdminQueueRetryCreateErrors[keyof AdminQueueRetryCreateErrors];
+export type AdminQueueRetryCreateResponses = {
+    /**
+     * Jobs queued for retry
+     */
+    200: {
+        success?: boolean;
+        /**
+         * Number of jobs queued for retry
+         */
+        retriedCount?: number;
+        message?: string;
+    };
+};
+export type AdminQueueRetryCreateResponse = AdminQueueRetryCreateResponses[keyof AdminQueueRetryCreateResponses];
+export type AdminQueueFailedDestroyData = {
+    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 AdminQueueFailedDestroyErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminQueueFailedDestroyError = AdminQueueFailedDestroyErrors[keyof AdminQueueFailedDestroyErrors];
+export type AdminQueueFailedDestroyResponses = {
+    /**
+     * Failed jobs purged successfully
+     */
+    200: {
+        success?: boolean;
+        /**
+         * Number of failed jobs deleted
+         */
+        purgedCount?: number;
+        message?: string;
+    };
+};
+export type AdminQueueFailedDestroyResponse = AdminQueueFailedDestroyResponses[keyof AdminQueueFailedDestroyResponses];
+export type AdminReportIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Cursor for pagination (report ID to start after)
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by report status
+         */
+        status?: 'PENDING' | 'CONCERN' | 'ACCEPTED' | 'REJECTED' | 'RESOLVED' | 'IGNORED';
+        /**
+         * Filter by report source
+         */
+        source?: 'USER' | 'AUTO';
+        /**
+         * Filter by target type
+         */
+        'target.type'?: 'SEGMENT' | 'EPISODE' | 'MEDIA';
+        /**
+         * Filter by target media ID
+         */
+        'target.mediaId'?: number;
+        /**
+         * Filter by target episode number
+         */
+        'target.episodeNumber'?: number;
+        /**
+         * Filter by target segment UUID
+         */
+        'target.segmentUuid'?: string;
+        /**
+         * Filter by review check run ID
+         */
+        reviewCheckRunId?: number;
+    };
+    url: '/v1/admin/reports';
+};
+export type AdminReportIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReportIndexError = AdminReportIndexErrors[keyof AdminReportIndexErrors];
+export type AdminReportIndexResponses = {
+    /**
+     * OK
+     */
+    200: AdminReportListResponse;
+};
+export type AdminReportIndexResponse = AdminReportIndexResponses[keyof AdminReportIndexResponses];
+export type AdminReportUpdateData = {
+    body: UpdateReportRequest;
+    path: {
+        /**
+         * Report ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/reports/{id}';
+};
+export type AdminReportUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReportUpdateError = AdminReportUpdateErrors[keyof AdminReportUpdateErrors];
+export type AdminReportUpdateResponses = {
+    /**
+     * Report updated successfully
+     */
+    200: Report;
+};
+export type AdminReportUpdateResponse = AdminReportUpdateResponses[keyof AdminReportUpdateResponses];
+export type AdminReviewRunCreateData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Optional category filter
+         */
+        category?: 'ANIME' | 'JDRAMA';
+        /**
+         * Optional check name to run a single check instead of all
+         */
+        checkName?: string;
+    };
+    url: '/v1/admin/review/run';
+};
+export type AdminReviewRunCreateErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewRunCreateError = AdminReviewRunCreateErrors[keyof AdminReviewRunCreateErrors];
+export type AdminReviewRunCreateResponses = {
+    /**
+     * Check run completed
+     */
+    200: RunReviewResponse;
+};
+export type AdminReviewRunCreateResponse = AdminReviewRunCreateResponses[keyof AdminReviewRunCreateResponses];
+export type AdminReviewCheckIndexData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/admin/review/checks';
+};
+export type AdminReviewCheckIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewCheckIndexError = AdminReviewCheckIndexErrors[keyof AdminReviewCheckIndexErrors];
+export type AdminReviewCheckIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<ReviewCheck>;
+};
+export type AdminReviewCheckIndexResponse = AdminReviewCheckIndexResponses[keyof AdminReviewCheckIndexResponses];
+export type AdminReviewCheckUpdateData = {
+    body: {
+        /**
+         * New threshold values
+         */
+        threshold?: {
+            [key: string]: unknown;
+        };
+        /**
+         * Enable or disable this check
+         */
+        enabled?: boolean;
+    };
+    path: {
+        /**
+         * Check name identifier
+         */
+        name: string;
+    };
+    query?: never;
+    url: '/v1/admin/review/checks/{name}';
+};
+export type AdminReviewCheckUpdateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewCheckUpdateError = AdminReviewCheckUpdateErrors[keyof AdminReviewCheckUpdateErrors];
+export type AdminReviewCheckUpdateResponses = {
+    /**
+     * Check updated successfully
+     */
+    200: ReviewCheck;
+};
+export type AdminReviewCheckUpdateResponse = AdminReviewCheckUpdateResponses[keyof AdminReviewCheckUpdateResponses];
+export type AdminReviewRunIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by check name
+         */
+        checkName?: string;
+        /**
+         * Cursor for pagination
+         */
+        cursor?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+    };
+    url: '/v1/admin/review/runs';
+};
+export type AdminReviewRunIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewRunIndexError = AdminReviewRunIndexErrors[keyof AdminReviewRunIndexErrors];
+export type AdminReviewRunIndexResponses = {
+    /**
+     * OK
+     */
+    200: {
+        runs: Array<ReviewCheckRun>;
+        pagination: CursorPagination;
+    };
+};
+export type AdminReviewRunIndexResponse = AdminReviewRunIndexResponses[keyof AdminReviewRunIndexResponses];
+export type AdminReviewRunShowData = {
+    body?: never;
+    path: {
+        /**
+         * Run ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/review/runs/{id}';
+};
+export type AdminReviewRunShowErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewRunShowError = AdminReviewRunShowErrors[keyof AdminReviewRunShowErrors];
+export type AdminReviewRunShowResponses = {
+    /**
+     * OK
+     */
+    200: {
+        run: ReviewCheckRun;
+        reports: Array<Report>;
+    };
+};
+export type AdminReviewRunShowResponse = AdminReviewRunShowResponses[keyof AdminReviewRunShowResponses];
+export type AdminReviewAllowlistIndexData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by check name
+         */
+        checkName?: string;
+    };
+    url: '/v1/admin/review/allowlist';
+};
+export type AdminReviewAllowlistIndexErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewAllowlistIndexError = AdminReviewAllowlistIndexErrors[keyof AdminReviewAllowlistIndexErrors];
+export type AdminReviewAllowlistIndexResponses = {
+    /**
+     * OK
+     */
+    200: Array<ReviewAllowlist>;
+};
+export type AdminReviewAllowlistIndexResponse = AdminReviewAllowlistIndexResponses[keyof AdminReviewAllowlistIndexResponses];
+export type AdminReviewAllowlistCreateData = {
+    body: {
+        /**
+         * Check name to allowlist for
+         */
+        checkName: string;
+        /**
+         * Media ID to allowlist
+         */
+        mediaId: number;
+        /**
+         * Episode number (for episode-level checks)
+         */
+        episodeNumber?: number;
+        /**
+         * Reason for allowlisting
+         */
+        reason?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/admin/review/allowlist';
+};
+export type AdminReviewAllowlistCreateErrors = {
+    /**
+     * Bad Request
+     */
+    400: Error400;
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Conflict
+     */
+    409: Error409;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewAllowlistCreateError = AdminReviewAllowlistCreateErrors[keyof AdminReviewAllowlistCreateErrors];
+export type AdminReviewAllowlistCreateResponses = {
+    /**
+     * Added to allowlist
+     */
+    201: ReviewAllowlist;
+};
+export type AdminReviewAllowlistCreateResponse = AdminReviewAllowlistCreateResponses[keyof AdminReviewAllowlistCreateResponses];
+export type AdminReviewAllowlistDestroyData = {
+    body?: never;
+    path: {
+        /**
+         * Allowlist entry ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/v1/admin/review/allowlist/{id}';
+};
+export type AdminReviewAllowlistDestroyErrors = {
+    /**
+     * Unauthorized
+     */
+    401: Error401;
+    /**
+     * Forbidden
+     */
+    403: Error403;
+    /**
+     * Not Found
+     */
+    404: Error404;
+    /**
+     * Too Many Requests
+     */
+    429: Error429;
+    /**
+     * Internal Server Error
+     */
+    500: Error500;
+};
+export type AdminReviewAllowlistDestroyError = AdminReviewAllowlistDestroyErrors[keyof AdminReviewAllowlistDestroyErrors];
+export type AdminReviewAllowlistDestroyResponses = {
+    /**
+     * Removed from allowlist
+     */
+    204: void;
+};
+export type AdminReviewAllowlistDestroyResponse = AdminReviewAllowlistDestroyResponses[keyof AdminReviewAllowlistDestroyResponses];
+//# sourceMappingURL=types.gen.d.ts.map