/** Zod input schemas for MCP tool validation. */
import { z } from "zod";
/** Input for searching anime or manga by title and filters */
export declare const SearchInputSchema: z.ZodObject<{
    query: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    genre: z.ZodOptional<z.ZodString>;
    year: z.ZodOptional<z.ZodNumber>;
    format: z.ZodOptional<z.ZodEnum<{
        MANGA: "MANGA";
        TV: "TV";
        MOVIE: "MOVIE";
        OVA: "OVA";
        ONA: "ONA";
        SPECIAL: "SPECIAL";
        NOVEL: "NOVEL";
        ONE_SHOT: "ONE_SHOT";
    }>>;
    isAdult: z.ZodDefault<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type SearchInput = z.infer<typeof SearchInputSchema>;
/** Input for looking up a single anime or manga by ID or title */
export declare const DetailsInputSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type DetailsInput = z.infer<typeof DetailsInputSchema>;
/** Input for fetching a user's anime or manga list */
export declare const ListInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    status: z.ZodDefault<z.ZodEnum<{
        CURRENT: "CURRENT";
        COMPLETED: "COMPLETED";
        PLANNING: "PLANNING";
        DROPPED: "DROPPED";
        PAUSED: "PAUSED";
        ALL: "ALL";
        CUSTOM: "CUSTOM";
    }>>;
    customListName: z.ZodOptional<z.ZodString>;
    sort: z.ZodDefault<z.ZodEnum<{
        SCORE: "SCORE";
        TITLE: "TITLE";
        UPDATED: "UPDATED";
        PROGRESS: "PROGRESS";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type ListInput = z.infer<typeof ListInputSchema>;
/** Input for looking up a single entry on a user's list */
export declare const LookupInputSchema: z.ZodObject<{
    mediaId: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    username: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type LookupInput = z.infer<typeof LookupInputSchema>;
/** Input for generating a taste profile summary */
export declare const TasteInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
        BOTH: "BOTH";
    }>>;
}, z.core.$strip>;
export type TasteInput = z.infer<typeof TasteInputSchema>;
/** Input for personalized recommendations from the user's planning list */
export declare const PickInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    profileType: z.ZodOptional<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    source: z.ZodDefault<z.ZodEnum<{
        PLANNING: "PLANNING";
        SEASONAL: "SEASONAL";
        DISCOVER: "DISCOVER";
    }>>;
    season: z.ZodOptional<z.ZodEnum<{
        WINTER: "WINTER";
        SPRING: "SPRING";
        SUMMER: "SUMMER";
        FALL: "FALL";
    }>>;
    year: z.ZodOptional<z.ZodNumber>;
    mood: z.ZodOptional<z.ZodString>;
    maxEpisodes: z.ZodOptional<z.ZodNumber>;
    exclude: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type PickInput = z.infer<typeof PickInputSchema>;
/** Input for planning a watch/read session within a time budget */
export declare const SessionInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    minutes: z.ZodNumber;
    mood: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type SessionInput = z.infer<typeof SessionInputSchema>;
/** Input for finding sequels to completed titles airing this season */
export declare const SequelAlertInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    season: z.ZodOptional<z.ZodEnum<{
        WINTER: "WINTER";
        SPRING: "SPRING";
        SUMMER: "SUMMER";
        FALL: "FALL";
    }>>;
    year: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
export type SequelAlertInput = z.infer<typeof SequelAlertInputSchema>;
/** Input for franchise watch order guidance */
export declare const WatchOrderInputSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    includeSpecials: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
export type WatchOrderInput = z.infer<typeof WatchOrderInputSchema>;
/** Input for comparing taste profiles between two users */
export declare const CompareInputSchema: z.ZodObject<{
    user1: z.ZodString;
    user2: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type CompareInput = z.infer<typeof CompareInputSchema>;
/** Input for browsing anime by season */
export declare const SeasonalInputSchema: z.ZodObject<{
    season: z.ZodOptional<z.ZodEnum<{
        WINTER: "WINTER";
        SPRING: "SPRING";
        SUMMER: "SUMMER";
        FALL: "FALL";
    }>>;
    year: z.ZodOptional<z.ZodNumber>;
    sort: z.ZodDefault<z.ZodEnum<{
        SCORE: "SCORE";
        POPULARITY: "POPULARITY";
        TRENDING: "TRENDING";
    }>>;
    isAdult: z.ZodDefault<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type SeasonalInput = z.infer<typeof SeasonalInputSchema>;
/** Input for fetching user statistics */
export declare const StatsInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type StatsInput = z.infer<typeof StatsInputSchema>;
/** Input for year-in-review summary */
export declare const WrappedInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    year: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
        BOTH: "BOTH";
    }>>;
}, z.core.$strip>;
export type WrappedInput = z.infer<typeof WrappedInputSchema>;
/** Input for trending anime/manga */
export declare const TrendingInputSchema: z.ZodObject<{
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    isAdult: z.ZodDefault<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type TrendingInput = z.infer<typeof TrendingInputSchema>;
/** Input for browsing by genre */
export declare const GenreBrowseInputSchema: z.ZodObject<{
    genre: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    year: z.ZodOptional<z.ZodNumber>;
    status: z.ZodOptional<z.ZodEnum<{
        FINISHED: "FINISHED";
        RELEASING: "RELEASING";
        NOT_YET_RELEASED: "NOT_YET_RELEASED";
        CANCELLED: "CANCELLED";
        HIATUS: "HIATUS";
    }>>;
    format: z.ZodOptional<z.ZodEnum<{
        MANGA: "MANGA";
        TV: "TV";
        MOVIE: "MOVIE";
        OVA: "OVA";
        ONA: "ONA";
        SPECIAL: "SPECIAL";
        NOVEL: "NOVEL";
        ONE_SHOT: "ONE_SHOT";
    }>>;
    sort: z.ZodDefault<z.ZodEnum<{
        SCORE: "SCORE";
        POPULARITY: "POPULARITY";
        TRENDING: "TRENDING";
    }>>;
    isAdult: z.ZodDefault<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type GenreBrowseInput = z.infer<typeof GenreBrowseInputSchema>;
/** Input for staff/VA credits lookup */
export declare const StaffInputSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    language: z.ZodDefault<z.ZodEnum<{
        JAPANESE: "JAPANESE";
        ENGLISH: "ENGLISH";
        KOREAN: "KOREAN";
        ITALIAN: "ITALIAN";
        SPANISH: "SPANISH";
        PORTUGUESE: "PORTUGUESE";
        FRENCH: "FRENCH";
        GERMAN: "GERMAN";
        HEBREW: "HEBREW";
        HUNGARIAN: "HUNGARIAN";
    }>>;
}, z.core.$strip>;
export type StaffInput = z.infer<typeof StaffInputSchema>;
/** Input for airing schedule lookup */
export declare const ScheduleInputSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type ScheduleInput = z.infer<typeof ScheduleInputSchema>;
/** Input for airing tracker across currently watching titles */
export declare const AiringTrackerInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type AiringTrackerInput = z.infer<typeof AiringTrackerInputSchema>;
/** Input for importing a MyAnimeList user's list for recommendations */
export declare const MalImportInputSchema: z.ZodObject<{
    malUsername: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type MalImportInput = z.infer<typeof MalImportInputSchema>;
/** Input for importing a Kitsu user's completed list */
export declare const KitsuImportInputSchema: z.ZodObject<{
    kitsuUsername: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type KitsuImportInput = z.infer<typeof KitsuImportInputSchema>;
/** Input for character search */
export declare const CharacterSearchInputSchema: z.ZodObject<{
    query: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type CharacterSearchInput = z.infer<typeof CharacterSearchInputSchema>;
/** Input for community recommendations for a specific title */
export declare const RecommendationsInputSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type RecommendationsInput = z.infer<typeof RecommendationsInputSchema>;
/** Input for updating episode or chapter progress */
export declare const UpdateProgressInputSchema: z.ZodObject<{
    mediaId: z.ZodNumber;
    progress: z.ZodNumber;
    volumeProgress: z.ZodOptional<z.ZodNumber>;
    status: z.ZodOptional<z.ZodEnum<{
        CURRENT: "CURRENT";
        COMPLETED: "COMPLETED";
        DROPPED: "DROPPED";
        PAUSED: "PAUSED";
        REPEATING: "REPEATING";
    }>>;
}, z.core.$strip>;
export type UpdateProgressInput = z.infer<typeof UpdateProgressInputSchema>;
/** Input for adding a title to the user's list */
export declare const AddToListInputSchema: z.ZodObject<{
    mediaId: z.ZodNumber;
    status: z.ZodEnum<{
        CURRENT: "CURRENT";
        COMPLETED: "COMPLETED";
        PLANNING: "PLANNING";
        DROPPED: "DROPPED";
        PAUSED: "PAUSED";
        REPEATING: "REPEATING";
    }>;
    score: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
export type AddToListInput = z.infer<typeof AddToListInputSchema>;
/** Input for rating a title */
export declare const RateInputSchema: z.ZodObject<{
    mediaId: z.ZodNumber;
    score: z.ZodNumber;
}, z.core.$strip>;
export type RateInput = z.infer<typeof RateInputSchema>;
/** Input for removing a title from the list */
export declare const DeleteFromListInputSchema: z.ZodObject<{
    entryId: z.ZodOptional<z.ZodNumber>;
    mediaId: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
/** Input for scoring a title against a user's taste profile */
export declare const ExplainInputSchema: z.ZodObject<{
    mediaId: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
        BOTH: "BOTH";
    }>>;
    mood: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type ExplainInput = z.infer<typeof ExplainInputSchema>;
/** Input for finding titles similar to a specific anime or manga */
export declare const SimilarInputSchema: z.ZodObject<{
    mediaId: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type SimilarInput = z.infer<typeof SimilarInputSchema>;
/** Input for searching staff/people by name */
export declare const StaffSearchInputSchema: z.ZodObject<{
    query: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
    mediaLimit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type StaffSearchInput = z.infer<typeof StaffSearchInputSchema>;
/** Input for listing all valid genres and tags */
export declare const GenreListInputSchema: z.ZodObject<{
    includeAdultTags: z.ZodDefault<z.ZodBoolean>;
    filter: z.ZodDefault<z.ZodEnum<{
        all: "all";
        genres: "genres";
        tags: "tags";
    }>>;
    category: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type GenreListInput = z.infer<typeof GenreListInputSchema>;
/** Input for searching studios by name */
export declare const StudioSearchInputSchema: z.ZodObject<{
    query: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type StudioSearchInput = z.infer<typeof StudioSearchInputSchema>;
/** Input for toggling a favourite */
export declare const FavouriteInputSchema: z.ZodObject<{
    type: z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
        CHARACTER: "CHARACTER";
        STAFF: "STAFF";
        STUDIO: "STUDIO";
    }>;
    id: z.ZodNumber;
}, z.core.$strip>;
export type FavouriteInput = z.infer<typeof FavouriteInputSchema>;
/** Input for posting a text activity */
export declare const PostActivityInputSchema: z.ZodObject<{
    text: z.ZodString;
}, z.core.$strip>;
export type PostActivityInput = z.infer<typeof PostActivityInputSchema>;
/** Input for fetching a user's activity feed */
export declare const FeedInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ALL: "ALL";
        TEXT: "TEXT";
        ANIME_LIST: "ANIME_LIST";
        MANGA_LIST: "MANGA_LIST";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type FeedInput = z.infer<typeof FeedInputSchema>;
/** Input for viewing a user's profile */
export declare const ProfileInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type ProfileInput = z.infer<typeof ProfileInputSchema>;
/** Input for fetching community reviews for a title */
export declare const ReviewsInputSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    title: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    sort: z.ZodDefault<z.ZodEnum<{
        HELPFUL: "HELPFUL";
        NEWEST: "NEWEST";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type ReviewsInput = z.infer<typeof ReviewsInputSchema>;
/** Input for score calibration analysis */
export declare const CalibrationInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type CalibrationInput = z.infer<typeof CalibrationInputSchema>;
/** Input for drop pattern analysis */
export declare const DropPatternInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type DropPatternInput = z.infer<typeof DropPatternInputSchema>;
/** Input for genre evolution over time */
export declare const EvolutionInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type EvolutionInput = z.infer<typeof EvolutionInputSchema>;
/** Input for franchise completion tracking */
export declare const CompletionistInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type CompletionistInput = z.infer<typeof CompletionistInputSchema>;
/** Input for seasonal pick-up and completion rates */
export declare const SeasonalHitRateInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    season: z.ZodOptional<z.ZodEnum<{
        WINTER: "WINTER";
        SPRING: "SPRING";
        SUMMER: "SUMMER";
        FALL: "FALL";
    }>>;
    year: z.ZodOptional<z.ZodNumber>;
    history: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type SeasonalHitRateInput = z.infer<typeof SeasonalHitRateInputSchema>;
/** Input for pace estimation */
export declare const PaceInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    mediaId: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type PaceInput = z.infer<typeof PaceInputSchema>;
/** Input for undoing the last write operation */
export declare const UndoInputSchema: z.ZodObject<{}, z.core.$strip>;
export type UndoInput = z.infer<typeof UndoInputSchema>;
/** Input for listing unscored completed titles */
export declare const UnscoredInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type UnscoredInput = z.infer<typeof UnscoredInputSchema>;
/** Input for batch-updating multiple list entries */
export declare const BatchUpdateInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    filter: z.ZodObject<{
        status: z.ZodOptional<z.ZodEnum<{
            CURRENT: "CURRENT";
            COMPLETED: "COMPLETED";
            PLANNING: "PLANNING";
            DROPPED: "DROPPED";
            PAUSED: "PAUSED";
        }>>;
        scoreBelow: z.ZodOptional<z.ZodNumber>;
        scoreAbove: z.ZodOptional<z.ZodNumber>;
        unscored: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    action: z.ZodObject<{
        setStatus: z.ZodOptional<z.ZodEnum<{
            CURRENT: "CURRENT";
            COMPLETED: "COMPLETED";
            PLANNING: "PLANNING";
            DROPPED: "DROPPED";
            PAUSED: "PAUSED";
            REPEATING: "REPEATING";
        }>>;
        setScore: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    dryRun: z.ZodDefault<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type BatchUpdateInput = z.infer<typeof BatchUpdateInputSchema>;
/** Input for group recommendations across multiple users */
export declare const GroupPickInputSchema: z.ZodObject<{
    users: z.ZodArray<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    source: z.ZodDefault<z.ZodEnum<{
        COMPLETED: "COMPLETED";
        PLANNING: "PLANNING";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type GroupPickInput = z.infer<typeof GroupPickInputSchema>;
/** Input for finding overlap between two users' planning lists */
export declare const SharedPlanningInputSchema: z.ZodObject<{
    user1: z.ZodString;
    user2: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type SharedPlanningInput = z.infer<typeof SharedPlanningInputSchema>;
/** Input for finding users with similar taste */
export declare const FollowSuggestionsInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type FollowSuggestionsInput = z.infer<typeof FollowSuggestionsInputSchema>;
/** Input for reacting to an activity (like or reply) */
export declare const ReactInputSchema: z.ZodObject<{
    activityId: z.ZodNumber;
    action: z.ZodEnum<{
        LIKE: "LIKE";
        REPLY: "REPLY";
    }>;
    text: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type ReactInput = z.infer<typeof ReactInputSchema>;
/** Input for generating a taste profile card image */
export declare const TasteCardInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type TasteCardInput = z.infer<typeof TasteCardInputSchema>;
/** Input for generating a compatibility card image */
export declare const CompatCardInputSchema: z.ZodObject<{
    user1: z.ZodString;
    user2: z.ZodString;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
}, z.core.$strip>;
export type CompatCardInput = z.infer<typeof CompatCardInputSchema>;
/** Input for generating a year-in-review card image */
export declare const WrappedCardInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    year: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
        BOTH: "BOTH";
    }>>;
}, z.core.$strip>;
export type WrappedCardInput = z.infer<typeof WrappedCardInputSchema>;
/** Input for generating a seasonal recap card image */
export declare const SeasonalRecapCardInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    season: z.ZodOptional<z.ZodEnum<{
        WINTER: "WINTER";
        SPRING: "SPRING";
        SUMMER: "SUMMER";
        FALL: "FALL";
    }>>;
    year: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
export type SeasonalRecapCardInput = z.infer<typeof SeasonalRecapCardInputSchema>;
/** Input for exporting a user's list as CSV or JSON */
export declare const ListExportInputSchema: z.ZodObject<{
    username: z.ZodOptional<z.ZodString>;
    type: z.ZodDefault<z.ZodEnum<{
        ANIME: "ANIME";
        MANGA: "MANGA";
    }>>;
    status: z.ZodOptional<z.ZodEnum<{
        CURRENT: "CURRENT";
        COMPLETED: "COMPLETED";
        PLANNING: "PLANNING";
        DROPPED: "DROPPED";
        PAUSED: "PAUSED";
    }>>;
    format: z.ZodDefault<z.ZodEnum<{
        csv: "csv";
        json: "json";
    }>>;
}, z.core.$strip>;
export type ListExportInput = z.infer<typeof ListExportInputSchema>;