type ProfilePicture = {
    url?: string;
    verified?: boolean;
};
type Bio = {
    text?: string;
    mentions?: Array<unknown>;
    channelMentions?: Array<unknown>;
};
type Location = {
    placeId?: string;
    description?: string;
};
type Profile = {
    bio?: Bio;
    location?: Location;
};
type ViewerContext = {
    following?: boolean;
    followedBy?: boolean;
    enableNotifications?: boolean;
    canSendDirectCasts?: boolean;
    hasUploadedInboxKeys?: boolean;
};
type User = {
    fid: number;
    username: string;
    displayName: string;
    pfp?: ProfilePicture;
    profile?: Profile;
    followerCount?: number;
    followingCount?: number;
    viewerContext?: ViewerContext;
};
type OnboardingState = {
    id?: string;
    email?: string;
    user?: User;
    hasOnboarding?: boolean;
    hasConfirmedEmail?: boolean;
    handledConnectAddress?: boolean;
    canRegisterUsername?: boolean;
    needsRegistrationPayment?: boolean;
    hasFid?: boolean;
    hasFname?: boolean;
    hasDelegatedSigner?: boolean;
    hasSetupProfile?: boolean;
    hasCompletedRegistration?: boolean;
    hasStorage?: boolean;
    handledPushNotificationsNudge?: boolean;
    handledContactsNudge?: boolean;
    handledInterestsNudge?: boolean;
    hasValidPaidInvite?: boolean;
    hasWarpcastWalletAddress?: boolean;
    hasPhone?: boolean;
    needsPhone?: boolean;
    sponsoredRegisterEligible?: boolean;
    geoRestricted?: boolean;
};
type OnboardingStateResponse = {
    result?: {
        state?: OnboardingState;
    };
};
type ErrorResponse = {
    errors?: Array<{
        /**
         * Error message describing the issue
         */
        message?: string;
    }>;
};
type UserWithExtras = User & {
    connectedAccounts?: Array<unknown>;
};
type UserExtras = {
    fid?: number;
    custodyAddress?: string;
    ethWallets?: Array<string>;
    solanaWallets?: Array<string>;
    walletLabels?: Array<{
        address?: string;
        labels?: Array<string>;
    }>;
    v2?: boolean;
    publicSpamLabel?: string;
};
type UserByFidResponse = {
    result?: {
        user?: UserWithExtras;
        collectionsOwned?: Array<unknown>;
        extras?: UserExtras;
    };
};
/**
 * Represents a single validation error
 */
type ValidationError = {
    /**
     * JSON Pointer to the part of the request that failed validation
     */
    instancePath: string;
    /**
     * JSON Schema path that was violated
     */
    schemaPath: string;
    /**
     * The JSON Schema keyword that failed
     */
    keyword: string;
    /**
     * Additional parameters describing the validation error
     */
    params?: {
        [key: string]: unknown;
    };
    /**
     * Human-readable error description
     */
    message: string;
};
/**
 * Standard 400 Bad Request error response
 */
type BadRequestError = {
    /**
     * Array of validation errors
     */
    errors: Array<ValidationError>;
};
type DirectCastMessageReaction = {
    /**
     * Emoji used for the reaction
     */
    reaction: string;
    /**
     * Number of users who reacted with this emoji
     */
    count: number;
    /**
     * Emoji used for the reaction (legacy field)
     */
    emoji?: string;
    /**
     * List of Farcaster IDs who reacted
     */
    userFids?: Array<number>;
};
type DirectCastMessageViewerContext = {
    /**
     * Whether this is the last read message
     */
    isLastReadMessage?: boolean;
    /**
     * Whether the message is focused
     */
    focused?: boolean;
    /**
     * User's reactions to this message
     */
    reactions?: Array<string>;
};
type DirectCastMessage = {
    /**
     * ID of the conversation this message belongs to
     */
    conversationId: string;
    /**
     * Farcaster ID of the message sender
     */
    senderFid: number;
    /**
     * Unique identifier for the message
     */
    messageId: string;
    /**
     * Server timestamp when message was sent (Unix milliseconds)
     */
    serverTimestamp: bigint;
    /**
     * Type of the message
     */
    type: "text" | "image" | "reaction" | "link" | "group_membership_addition" | "pin_message" | "message_ttl_change";
    /**
     * Content of the message
     */
    message: string;
    /**
     * Whether the message contains mentions
     */
    hasMention: boolean;
    /**
     * List of reactions to the message
     */
    reactions: Array<DirectCastMessageReaction>;
    /**
     * Whether the message is pinned
     */
    isPinned: boolean;
    /**
     * Whether the message is deleted
     */
    isDeleted: boolean;
    senderContext: User;
    viewerContext?: DirectCastMessageViewerContext;
    inReplyTo?: DirectCastMessage;
    metadata?: DirectCastMessageMetadata;
    actionTargetUserContext?: User;
    /**
     * Whether the message was sent programmatically
     */
    isProgrammatic?: boolean;
    /**
     * List of mentions in the message
     */
    mentions?: Array<DirectCastMessageMention>;
};
type DirectCastMessageMetadata = {
    /**
     * Cast metadata if message contains cast references
     */
    casts?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * URL metadata if message contains links
     */
    urls?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * Media metadata if message contains media
     */
    medias?: Array<{
        [key: string]: unknown;
    }>;
};
type DirectCastMessageMention = {
    user: User;
    /**
     * Starting index of the mention in the message text
     */
    textIndex: number;
    /**
     * Length of the mention text
     */
    length: number;
};
type DirectCastConversationViewerContext = {
    /**
     * Access level for the conversation
     */
    access?: "read-write" | "read-only";
    /**
     * Category of the conversation
     */
    category?: string;
    /**
     * Whether the conversation is archived
     */
    archived?: boolean;
    /**
     * Timestamp of last read (Unix milliseconds)
     */
    lastReadAt?: bigint;
    /**
     * Whether the conversation is muted
     */
    muted?: boolean;
    /**
     * Whether the conversation is manually marked as unread
     */
    manuallyMarkedUnread?: boolean;
    /**
     * Whether the conversation is pinned
     */
    pinned?: boolean;
    /**
     * Number of unread messages
     */
    unreadCount?: number;
    /**
     * Number of unread mentions
     */
    unreadMentionsCount?: number;
    /**
     * The other participant in a 1:1 conversation
     */
    counterParty?: User;
    /**
     * Tag associated with the conversation
     */
    tag?: string;
};
type DirectCastConversation = {
    /**
     * Unique identifier for the conversation
     */
    conversationId: string;
    /**
     * Name of the conversation (for group conversations)
     */
    name?: string;
    /**
     * Description of the conversation
     */
    description?: string;
    /**
     * URL of the conversation photo
     */
    photoUrl?: string;
    /**
     * List of admin Farcaster IDs
     */
    adminFids: Array<number>;
    /**
     * List of removed Farcaster IDs
     */
    removedFids?: Array<number>;
    /**
     * List of conversation participants
     */
    participants?: Array<User>;
    /**
     * Timestamp of last read time (Unix milliseconds)
     */
    lastReadTime: bigint;
    /**
     * Timestamp of viewer's last read time (Unix milliseconds)
     */
    selfLastReadTime?: bigint;
    /**
     * List of pinned messages in the conversation
     */
    pinnedMessages?: Array<DirectCastMessage>;
    /**
     * Whether the conversation has pinned messages
     */
    hasPinnedMessages?: boolean;
    /**
     * Whether this is a group conversation
     */
    isGroup: boolean;
    /**
     * Whether the conversation is collection token gated
     */
    isCollectionTokenGated?: boolean;
    /**
     * Number of active participants in the conversation
     */
    activeParticipantsCount?: number;
    /**
     * Message time-to-live in days, or "Infinity" for no expiration
     */
    messageTTLDays?: number | "Infinity";
    /**
     * Timestamp when conversation was created (Unix milliseconds)
     */
    createdAt: bigint;
    /**
     * Number of unread messages
     */
    unreadCount?: number;
    /**
     * Whether the conversation is muted
     */
    muted?: boolean;
    /**
     * Whether the conversation has mentions
     */
    hasMention?: boolean;
    lastMessage?: DirectCastMessage;
    viewerContext: DirectCastConversationViewerContext;
};
type DirectCastInboxResult = {
    /**
     * Whether user has archived conversations
     */
    hasArchived: boolean;
    /**
     * Whether user has unread conversation requests
     */
    hasUnreadRequests: boolean;
    /**
     * Total number of conversation requests
     */
    requestsCount: number;
    conversations: Array<DirectCastConversation>;
};
type PaginationCursor = {
    /**
     * Base64 encoded cursor for pagination
     */
    cursor?: string;
    [key: string]: unknown | string | undefined;
};
type DirectCastInboxResponse = {
    result: DirectCastInboxResult;
    next?: PaginationCursor;
};
type CastAction = {
    id?: string;
    name?: string;
    octicon?: string;
    actionUrl?: string;
    action?: {
        actionType?: string;
        postUrl?: string;
    };
};
type UserAppContextResponse = {
    result?: {
        context?: {
            canAddLinks?: boolean;
            showConnectedApps?: boolean;
            signerRequestsEnabled?: boolean;
            prompts?: Array<unknown>;
            adminForChannelKeys?: Array<string>;
            modOfChannelKeys?: Array<string>;
            memberOfChannelKeys?: Array<string>;
            canEditAllChannels?: boolean;
            canUploadVideo?: boolean;
            statsigEnabled?: boolean;
            shouldPromptForPushNotifications?: boolean;
            shouldPromptForUserFollowsSyncContacts?: boolean;
            castActions?: Array<CastAction>;
            canAddCastAction?: boolean;
            enabledCastAction?: CastAction;
            notificationTabsV2?: Array<{
                id?: string;
                name?: string;
            }>;
            enabledVideoAutoplay?: boolean;
            regularCastByteLimit?: number;
            longCastByteLimit?: number;
            newUserStatus?: {
                [key: string]: unknown;
            };
            country?: string;
            higherClientEventSamplingRateEnabled?: boolean;
        };
    };
};
type UserPreferencesResponse = {
    result?: {
        preferences?: {
            [key: string]: unknown;
        };
    };
};
type Channel = {
    type?: string;
    key?: string;
    name?: string;
    imageUrl?: string;
    fastImageUrl?: string;
    feeds?: Array<{
        name?: string;
        type?: string;
    }>;
    description?: string;
    followerCount?: number;
    memberCount?: number;
    showCastSourceLabels?: boolean;
    showCastTags?: boolean;
    sectionRank?: number;
    subscribable?: boolean;
    publicCasting?: boolean;
    inviteCode?: string;
    headerImageUrl?: string;
    headerAction?: {
        title?: string;
        target?: string;
    };
    headerActionMetadata?: {
        [key: string]: unknown;
    };
    viewerContext?: {
        following?: boolean;
        isMember?: boolean;
        hasUnseenItems?: boolean;
        favoritePosition?: number;
        activityRank?: number;
        canCast?: boolean;
    };
};
type HighlightedChannelsResponse = {
    result?: {
        channels?: Array<Channel>;
        viewerContext?: {
            defaultFeed?: string;
        };
    };
};
type ImageEmbed = {
    type?: "image";
    url?: string;
    sourceUrl?: string;
    media?: {
        version?: string;
        width?: number;
        height?: number;
        staticRaster?: string;
        mimeType?: string;
    };
    alt?: string;
};
type UrlEmbed = {
    type: "url";
    openGraph: {
        url: string;
        sourceUrl?: string;
        title?: string;
        description?: string;
        domain?: string;
        image?: string;
        useLargeImage?: boolean;
    };
};
type VideoEmbed = {
    type?: "video";
};
type Recaster = {
    fid?: number;
    username?: string;
    displayName?: string;
    recastHash?: string;
};
type Cast = {
    /**
     * Unique hash identifier for the cast
     */
    hash: string;
    /**
     * Hash identifier for the thread this cast belongs to
     */
    threadHash?: string;
    /**
     * Hash identifier of the parent cast (if this is a reply)
     */
    parentHash?: string;
    parentSource?: {
        type?: "url";
        url?: string;
    };
    author: User;
    /**
     * The text content of the cast
     */
    text: string;
    /**
     * Unix timestamp in milliseconds
     */
    timestamp: bigint;
    mentions?: Array<User>;
    embeds?: {
        images?: Array<ImageEmbed>;
        urls?: Array<UrlEmbed>;
        videos?: Array<VideoEmbed>;
        unknowns?: Array<{
            [key: string]: unknown;
        }>;
        processedCastText?: string;
        groupInvites?: Array<{
            [key: string]: unknown;
        }>;
    };
    replies: {
        count: number;
    };
    reactions: {
        count: number;
    };
    recasts: {
        count: number;
        recasters?: Array<Recaster>;
    };
    watches: {
        count: number;
    };
    recast?: boolean;
    tags?: Array<{
        type?: string;
        id?: string;
        name?: string;
        imageUrl?: string;
    }>;
    quoteCount?: number;
    combinedRecastCount?: number;
    channel?: {
        key?: string;
        name?: string;
        imageUrl?: string;
        authorContext?: {
            role?: string;
            restricted?: boolean;
            banned?: boolean;
        };
        authorRole?: string;
    };
    viewerContext?: {
        reacted?: boolean;
        recast?: boolean;
        bookmarked?: boolean;
    };
};
type FeedItemsResponse = {
    result: {
        items: Array<{
            id: string;
            timestamp: number;
            cast: Cast;
            otherParticipants?: Array<User>;
        }>;
        latestMainCastTimestamp?: number;
        feedTopSeenAtTimestamp?: number;
        replaceFeed: boolean;
    };
};
type GenericResponse = {
    result: {
        [key: string]: unknown;
    };
};
type UserResponse = GenericResponse & {
    result: {
        user?: UserWithExtras;
        collectionsOwned?: Array<{
            [key: string]: unknown;
        }>;
        extras?: UserExtras;
    };
};
type PaginatedResponse = {
    result: {
        [key: string]: unknown;
    };
    next?: PaginationCursor;
};
type SuggestedUsersResponse = PaginatedResponse & {
    result?: {
        users?: Array<{
            [key: string]: unknown;
        }>;
    };
};
type FavoriteFramesResponse = {
    result: {
        frames: Array<{
            [key: string]: unknown;
        }>;
    };
};
type ChannelStreaksResponse = {
    result: {
        [key: string]: unknown;
    };
};
type UnseenCountsResponse = {
    result: {
        notificationsCount?: number;
        notificationTabs?: Array<{
            tab: string;
            unseenCount: number;
        }>;
        inboxCount?: number;
        channelFeeds?: Array<{
            channelKey: string;
            feedType: string;
            hasNewItems: boolean;
        }>;
        warpTransactionCount?: number;
    };
};
type UserThreadCastsResponse = {
    result: {
        casts: Array<{
            [key: string]: unknown;
        }>;
    };
};
type ChannelFollowersYouKnowResponse = {
    result: {
        users: Array<{
            [key: string]: unknown;
        }>;
        totalCount: number;
    };
};
type SuccessResponse = GenericResponse & {
    result?: {
        /**
         * Whether the operation was successful
         */
        success: boolean;
    };
};
type NotificationsResponse = {
    result: {
        notifications?: Array<{
            [key: string]: unknown;
        }>;
    };
};
type DirectCastConversationResponse = GenericResponse & {
    result?: {
        conversation: DirectCastConversation;
    };
};
type DirectCastConversationCategorizationRequest = {
    /**
     * ID of the conversation to categorize
     */
    conversationId: string;
    /**
     * Category to assign to the conversation
     */
    category: string;
};
type DirectCastConversationMessagesResponse = PaginatedResponse & {
    result?: {
        messages: Array<DirectCastMessage>;
    };
};
type DirectCastConversationMessageTtlRequest = {
    /**
     * ID of the conversation to set message TTL for
     */
    conversationId: string;
    /**
     * Time to live for messages in days
     */
    ttl: number;
};
type DirectCastConversationNotificationsRequest = {
    /**
     * ID of the conversation to update notification settings for
     */
    conversationId: string;
    /**
     * Whether to mute notifications for this conversation
     */
    muted: boolean;
};
type DirectCastSendRequest = {
    /**
     * ID of the conversation to send the message to
     */
    conversationId: string;
    /**
     * Array of Farcaster IDs of message recipients
     */
    recipientFids: Array<number>;
    /**
     * Unique identifier for the message
     */
    messageId: string;
    /**
     * Type of the message
     */
    type: "text" | "image" | "reaction" | "link";
    /**
     * Content of the message
     */
    message: string;
    /**
     * ID of the message this is replying to (optional)
     */
    inReplyToId?: string;
};
type DirectCastManuallyMarkUnreadRequest = {
    /**
     * ID of the conversation to mark as unread
     */
    conversationId: string;
};
type DirectCastMessageReactionRequest = {
    /**
     * ID of the conversation containing the message
     */
    conversationId: string;
    /**
     * ID of the message to react to
     */
    messageId: string;
    /**
     * Emoji reaction to add or remove
     */
    reaction: string;
};
type DirectCastPinConversationRequest = {
    /**
     * ID of the conversation to pin
     */
    conversationId: string;
};
type DiscoverChannelsResponse = GenericResponse & {
    result?: {
        channels?: Array<{
            [key: string]: unknown;
        }>;
    };
};
type InvitesAvailableResponse = GenericResponse & {
    result?: {
        /**
         * Total number of invites allocated to the user
         */
        allocatedInvitesCount: number;
        /**
         * Number of invites currently available to send
         */
        availableInvitesCount: number;
    };
};
type SponsoredInvitesResponse = GenericResponse & {
    result?: {
        invites?: Array<{
            [key: string]: unknown;
        }>;
    };
    [key: string]: unknown | {
        invites?: Array<{
            [key: string]: unknown;
        }>;
    } | undefined;
};
type RewardsLeaderboardResponse = {
    result: {
        leaderboard: {
            type: string;
            users: Array<{
                user?: {
                    [key: string]: unknown;
                };
                score?: number;
                rank?: number;
            }>;
        };
    };
};
type RewardsScoresResponse = {
    result: {
        scores: Array<{
            type?: string;
            user?: {
                [key: string]: unknown;
            };
            allTimeScore?: number;
            currentPeriodScore?: number;
            previousPeriodScore?: number;
        }>;
    };
};
type RewardsMetadataResponse = {
    result: {
        metadata?: {
            type?: string;
            lastUpdateTimestamp?: number;
            currentPeriodStartTimestamp?: number;
            currentPeriodEndTimestamp?: number;
            tiers?: Array<{
                [key: string]: unknown;
            }>;
            proportionalPayout?: {
                numWinners?: number;
                totalRewardCents?: number;
            };
        };
    };
};
type BookmarkedCast = {
    [key: string]: unknown;
};
type BookmarkedCastsResponse = {
    result: {
        bookmarks?: Array<BookmarkedCast>;
    };
};
type StarterPack = {
    /**
     * Unique identifier for the starter pack
     */
    id: string;
    creator?: User;
    /**
     * Display name of the starter pack
     */
    name?: string;
    /**
     * Description of the starter pack
     */
    description?: string;
    /**
     * URL for OG image preview
     */
    openGraphImageUrl?: string;
    /**
     * Number of items in the starter pack
     */
    itemCount?: number;
    /**
     * Items contained in the starter pack
     */
    items?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * Labels/tags for the starter pack
     */
    labels?: Array<string>;
    [key: string]: unknown | string | User | number | Array<{
        [key: string]: unknown;
    }> | Array<string> | undefined;
};
type StarterPacksResponse = {
    result: {
        starterPacks: Array<StarterPack>;
    };
};
type StarterPackResponse = {
    result: {
        starterPack: StarterPack;
    };
};
type StarterPackUpdateRequest = {
    /**
     * Unique identifier for the starter pack to update
     */
    id: string;
    /**
     * Display name of the starter pack
     */
    name: string;
    /**
     * Description of the starter pack
     */
    description: string;
    /**
     * List of FIDs included in the starter pack
     */
    fids: Array<number>;
    /**
     * Labels/tags for the starter pack
     */
    labels: Array<string>;
};
type StarterPackUsersResponse = {
    result: {
        users: Array<User>;
    };
};
type ChannelResponse = {
    result: {
        channel?: Channel;
    };
};
type ChannelUsersResponse = {
    result: {
        users?: Array<User>;
    };
};
type UsersResponse = {
    result: {
        users: Array<User>;
    };
};
type UsersWithCountResponse = {
    result: {
        users: Array<User>;
        totalCount: number;
    };
};
type FrameApp = {
    [key: string]: unknown;
};
type FrameAppsResponse = {
    result?: {
        frames?: Array<FrameApp>;
    };
};
/**
 * Context information for the viewer
 */
type MiniAppViewerContext = {
    [key: string]: unknown;
};
type MiniApp = {
    /**
     * The domain of the mini app
     */
    domain?: string;
    /**
     * The name of the mini app
     */
    name?: string;
    /**
     * URL to the mini app's icon
     */
    iconUrl?: string;
    /**
     * The home URL of the mini app
     */
    homeUrl?: string;
    author?: User;
    /**
     * Whether the mini app supports notifications
     */
    supportsNotifications?: boolean;
    /**
     * Unique identifier for the mini app
     */
    id?: string;
    /**
     * Short identifier for the mini app
     */
    shortId?: string;
    /**
     * URL to the mini app's main image
     */
    imageUrl?: string;
    /**
     * Title for the action button
     */
    buttonTitle?: string;
    /**
     * URL to the splash screen image
     */
    splashImageUrl?: string;
    /**
     * Background color for the splash screen
     */
    splashBackgroundColor?: string;
    /**
     * URL for sharing casts
     */
    castShareUrl?: string;
    /**
     * Subtitle of the mini app
     */
    subtitle?: string;
    /**
     * Description of the mini app
     */
    description?: string;
    /**
     * Tagline of the mini app
     */
    tagline?: string;
    /**
     * URL to the hero image
     */
    heroImageUrl?: string;
    /**
     * Primary category of the mini app
     */
    primaryCategory?: string;
    /**
     * Tags associated with the mini app
     */
    tags?: Array<string>;
    /**
     * URLs to screenshot images
     */
    screenshotUrls?: Array<string>;
    /**
     * Whether the mini app should be indexed
     */
    noindex?: boolean;
    /**
     * Open Graph title
     */
    ogTitle?: string;
    /**
     * Open Graph description
     */
    ogDescription?: string;
    /**
     * Open Graph image URL
     */
    ogImageUrl?: string;
    /**
     * Required capabilities for the mini app
     */
    requiredCapabilities?: Array<string>;
    /**
     * Required blockchain chains
     */
    requiredChains?: Array<string>;
    viewerContext?: MiniAppViewerContext;
};
type RankedMiniApp = {
    /**
     * Current rank of the mini app
     */
    rank?: number;
    miniApp?: MiniApp;
    /**
     * Change in rank over the last 72 hours
     */
    rank72hChange?: number;
};
type TopMiniAppsResponse = {
    result?: {
        miniApps?: Array<RankedMiniApp>;
        next?: PaginationCursor;
    };
};
type VerifiedAddress = {
    fid?: number;
    address?: string;
    timestamp?: number;
    version?: string;
    protocol?: string;
    isPrimary?: boolean;
    labels?: Array<string>;
};
type MutedKeywordProperties = {
    channels?: boolean;
    frames?: boolean;
    notifications?: boolean;
};
type MutedKeyword = {
    keyword: string;
    properties: MutedKeywordProperties;
};
type MutedKeywordsResponse = {
    success: boolean;
    result: {
        keywords: Array<string>;
        mutedKeywords: Array<MutedKeyword>;
    };
};
type CastHashResponse = {
    result: {
        castHash?: string;
    };
};
type AttachEmbedsResponse = {
    result: {
        [key: string]: unknown;
    };
};
type CastRecastersResponse = {
    result: {
        users?: Array<User>;
    };
};
type CastQuote = {
    hash?: string;
    threadHash?: string;
    parentSource?: {
        type?: string;
        url?: string;
    };
    author?: User;
    text?: string;
    timestamp?: number;
};
type CastQuotesResponse = {
    result: {
        quotes?: Array<CastQuote>;
    };
};
type UserResponseUserResponse = {
    result: {
        user: User;
    };
};
type SearchChannelsResponse = {
    result?: {
        channels?: Array<Channel>;
    };
};
type DraftsResponse = {
    result?: {
        drafts?: Array<unknown>;
    };
};
type DraftCast = {
    text?: string;
    embeds?: Array<unknown>;
};
type Draft = {
    draftId?: string;
    casts?: Array<DraftCast>;
};
type DraftCreatedResponse = {
    result?: {
        draft?: Draft;
    };
};
type CastCreatedResponse = {
    result?: {
        cast?: Cast;
    };
};
type RawChannel = {
    id?: string;
    url?: string;
    name?: string;
    description?: string;
    descriptionMentions?: Array<number>;
    descriptionMentionsPositions?: Array<number>;
    imageUrl?: string;
    headerImageUrl?: string;
    leadFid?: number;
    moderatorFids?: Array<number>;
    createdAt?: number;
    followerCount?: number;
    memberCount?: number;
    pinnedCastHash?: string;
    publicCasting?: boolean;
    externalLink?: {
        title?: string;
        url?: string;
    };
};
type ChannelListResponse = {
    result?: {
        channels?: Array<RawChannel>;
    };
};
type RawChannelResponse = {
    result?: {
        channel?: RawChannel;
    };
};
type ChannelFollower = {
    fid?: number;
    followedAt?: number;
};
type ChannelFollowersResponse = PaginatedResponse & {
    result?: {
        users?: Array<ChannelFollower>;
    };
};
type ChannelFollowStatus = {
    following?: boolean;
    followedAt?: number;
};
type ChannelFollowStatusResponse = {
    result?: ChannelFollowStatus;
};
type Action = {
    name?: string;
    icon?: string;
    description?: string;
    aboutUrl?: string;
    imageUrl?: string;
    actionUrl?: string;
    action?: {
        actionType?: "post" | "get" | "put" | "delete";
        postUrl?: string;
    };
};
type Winner = {
    /**
     * The fid of the winner
     */
    fid?: number;
    /**
     * The domain of the winner
     */
    domain?: string;
    /**
     * The name of the frame (mini app)
     */
    frameName?: string;
    /**
     * The score of the winner
     */
    score?: number;
    /**
     * The rank of the winner
     */
    rank?: number;
    /**
     * The reward amount in cents
     */
    rewardCents?: number;
    /**
     * The wallet address of the winner (optional)
     */
    walletAddress?: string;
};
type Frame = {
    domain?: string;
    name?: string;
    iconUrl?: string;
    homeUrl?: string;
    splashImageUrl?: string;
    splashBackgroundColor?: string;
    buttonTitle?: string | null;
    imageUrl?: string | null;
    supportsNotifications?: boolean;
    viewerContext?: {
        [key: string]: unknown;
    };
    author?: User;
};
type AppsByAuthorResponse = {
    result?: {
        frames?: Array<Frame>;
    };
};
type ApiKey = {
    /**
     * Unique identifier for the API key
     */
    id: string;
    /**
     * Timestamp when the API key was created (in milliseconds since epoch)
     */
    createdAt: bigint;
    /**
     * Timestamp when the API key expires (in milliseconds since epoch)
     */
    expiresAt: bigint;
    /**
     * Timestamp when the API key was revoked, if applicable (in milliseconds since epoch)
     */
    revokedAt?: string | null;
    /**
     * Short identifier tag for the API key
     */
    tag: string;
    /**
     * User-provided description of the API key's purpose
     */
    description: string;
};
/**
 * Generic 400 Bad Request error for simple error messages
 */
type GenericBadRequestError = {
    errors: Array<{
        /**
         * Error message describing the issue
         */
        message: string;
    }>;
};
type DirectCastSendResponse = SuccessResponse;
type DirectCastConversationCategorizationResponse = SuccessResponse;
type DirectCastConversationNotificationsResponse = SuccessResponse;
type DirectCastConversationMessageTtlResponse = SuccessResponse;
type DirectCastMessageReactionResponse = SuccessResponse;
/**
 * The user's FID (Farcaster ID)
 */
type FidParam = number;
/**
 * Maximum number of items to return
 */
type LimitParam = number;
/**
 * Base64 encoded cursor for pagination
 */
type CursorParam = string;
type GetUserOnboardingStateData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/onboarding-state";
};
type GetUserOnboardingStateErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserOnboardingStateError = GetUserOnboardingStateErrors[keyof GetUserOnboardingStateErrors];
type GetUserOnboardingStateResponses = {
    /**
     * Successful retrieval of onboarding state
     */
    200: OnboardingStateResponse;
};
type GetUserOnboardingStateResponse = GetUserOnboardingStateResponses[keyof GetUserOnboardingStateResponses];
type GetUserByFidData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
    };
    url: "/v2/user-by-fid";
};
type GetUserByFidErrors = {
    /**
     * Bad request - validation errors or malformed request
     */
    400: BadRequestError;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * The specified resource was not found
     */
    404: ErrorResponse;
};
type GetUserByFidError = GetUserByFidErrors[keyof GetUserByFidErrors];
type GetUserByFidResponses = {
    /**
     * Successful retrieval of user by fid
     */
    200: UserByFidResponse;
};
type GetUserByFidResponse = GetUserByFidResponses[keyof GetUserByFidResponses];
type GetDirectCastInboxData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        /**
         * Category of conversations to retrieve
         */
        category?: "default" | "requests" | "spam";
        /**
         * Filter for conversations (e.g., unread, all)
         */
        filter?: "unread" | "group" | "1-1";
        /**
         * Base64 encoded cursor from previous response
         */
        cursor?: string;
    };
    url: "/v2/direct-cast-inbox";
};
type GetDirectCastInboxErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetDirectCastInboxError = GetDirectCastInboxErrors[keyof GetDirectCastInboxErrors];
type GetDirectCastInboxResponses = {
    /**
     * Successful retrieval of direct cast inbox
     */
    200: DirectCastInboxResponse;
};
type GetDirectCastInboxResponse = GetDirectCastInboxResponses[keyof GetDirectCastInboxResponses];
type GetUserAppContextData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/user-app-context";
};
type GetUserAppContextErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserAppContextError = GetUserAppContextErrors[keyof GetUserAppContextErrors];
type GetUserAppContextResponses = {
    /**
     * Successful retrieval of user app context
     */
    200: UserAppContextResponse;
};
type GetUserAppContextResponse = GetUserAppContextResponses[keyof GetUserAppContextResponses];
type GetUserPreferencesData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/user-preferences";
};
type GetUserPreferencesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserPreferencesError = GetUserPreferencesErrors[keyof GetUserPreferencesErrors];
type GetUserPreferencesResponses = {
    /**
     * Successful retrieval of user preferences
     */
    200: UserPreferencesResponse;
};
type GetUserPreferencesResponse = GetUserPreferencesResponses[keyof GetUserPreferencesResponses];
type GetHighlightedChannelsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/highlighted-channels";
};
type GetHighlightedChannelsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetHighlightedChannelsError = GetHighlightedChannelsErrors[keyof GetHighlightedChannelsErrors];
type GetHighlightedChannelsResponses = {
    /**
     * Successful retrieval of highlighted channels
     */
    200: HighlightedChannelsResponse;
};
type GetHighlightedChannelsResponse = GetHighlightedChannelsResponses[keyof GetHighlightedChannelsResponses];
type GetFeedItemsData = {
    body: {
        /**
         * Identifier for the specific feed
         */
        feedKey: string;
        /**
         * Type of feed to retrieve
         */
        feedType: string;
        /**
         * Only return items older than this timestamp (ms)
         */
        olderThan?: bigint;
        /**
         * Latest main cast timestamp used for pagination (ms)
         */
        latestMainCastTimestamp?: bigint;
        /**
         * List of item ID prefixes to exclude from the response
         */
        excludeItemIdPrefixes?: Array<string>;
        /**
         * View events for casts
         */
        castViewEvents?: Array<{
            /**
             * Event timestamp in ms
             */
            ts: bigint;
            /**
             * Cast hash
             */
            hash: string;
            /**
             * Context of the view event
             */
            on: string;
            /**
             * Channel key
             */
            channel: string;
            /**
             * Feed type where event occurred
             */
            feed: string;
        }>;
        /**
         * Whether to update the feed state
         */
        updateState?: boolean;
    };
    path?: never;
    query?: never;
    url: "/v2/feed-items";
};
type GetFeedItemsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetFeedItemsError = GetFeedItemsErrors[keyof GetFeedItemsErrors];
type GetFeedItemsResponses = {
    /**
     * Successful retrieval of feed items
     */
    200: FeedItemsResponse;
};
type GetFeedItemsResponse = GetFeedItemsResponses[keyof GetFeedItemsResponses];
type GetUserData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
    };
    url: "/v2/user";
};
type GetUserErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * The specified resource was not found
     */
    404: ErrorResponse;
};
type GetUserError = GetUserErrors[keyof GetUserErrors];
type GetUserResponses = {
    /**
     * Successful retrieval of user information
     */
    200: UserResponse;
};
type GetUserResponse = GetUserResponses[keyof GetUserResponses];
type GetUserFollowingChannelsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Whether results are intended for the composer interface
         */
        forComposer?: boolean;
        /**
         * Maximum number of items to return
         */
        limit?: number;
    };
    url: "/v2/user-following-channels";
};
type GetUserFollowingChannelsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserFollowingChannelsError = GetUserFollowingChannelsErrors[keyof GetUserFollowingChannelsErrors];
type GetUserFollowingChannelsResponses = {
    /**
     * Successful retrieval of followed channels
     */
    200: HighlightedChannelsResponse;
};
type GetUserFollowingChannelsResponse = GetUserFollowingChannelsResponses[keyof GetUserFollowingChannelsResponses];
type GetSuggestedUsersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        randomized?: boolean;
    };
    url: "/v2/suggested-users";
};
type GetSuggestedUsersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetSuggestedUsersError = GetSuggestedUsersErrors[keyof GetSuggestedUsersErrors];
type GetSuggestedUsersResponses = {
    /**
     * Successful retrieval of suggested users
     */
    200: SuggestedUsersResponse;
};
type GetSuggestedUsersResponse = GetSuggestedUsersResponses[keyof GetSuggestedUsersResponses];
type GetUserFavoriteFramesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
    };
    url: "/v1/favorite-frames";
};
type GetUserFavoriteFramesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserFavoriteFramesError = GetUserFavoriteFramesErrors[keyof GetUserFavoriteFramesErrors];
type GetUserFavoriteFramesResponses = {
    /**
     * Successful retrieval of favorite frames
     */
    200: FavoriteFramesResponse;
};
type GetUserFavoriteFramesResponse = GetUserFavoriteFramesResponses[keyof GetUserFavoriteFramesResponses];
type GetUserByUsernameData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The username to look up
         */
        username: string;
    };
    url: "/v2/user-by-username";
};
type GetUserByUsernameErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * The specified resource was not found
     */
    404: ErrorResponse;
};
type GetUserByUsernameError = GetUserByUsernameErrors[keyof GetUserByUsernameErrors];
type GetUserByUsernameResponses = {
    /**
     * Successful retrieval of user by username
     */
    200: UserByFidResponse;
};
type GetUserByUsernameResponse = GetUserByUsernameResponses[keyof GetUserByUsernameResponses];
type GetChannelStreaksForUserData = {
    body?: never;
    path?: never;
    query: {
        fid: number;
    };
    url: "/v2/channel-streaks";
};
type GetChannelStreaksForUserErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelStreaksForUserError = GetChannelStreaksForUserErrors[keyof GetChannelStreaksForUserErrors];
type GetChannelStreaksForUserResponses = {
    /**
     * Successful retrieval of channel streaks
     */
    200: ChannelStreaksResponse;
};
type GetChannelStreaksForUserResponse = GetChannelStreaksForUserResponses[keyof GetChannelStreaksForUserResponses];
type GetUnseenCountsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/unseen";
};
type GetUnseenCountsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUnseenCountsError = GetUnseenCountsErrors[keyof GetUnseenCountsErrors];
type GetUnseenCountsResponses = {
    /**
     * Successful retrieval of unseen feed and notification data
     */
    200: UnseenCountsResponse;
};
type GetUnseenCountsResponse = GetUnseenCountsResponses[keyof GetUnseenCountsResponses];
type GetUserThreadCastsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        /**
         * The hash prefix of the cast
         */
        castHashPrefix: string;
        /**
         * The username of the user
         */
        username: string;
    };
    url: "/v2/user-thread-casts";
};
type GetUserThreadCastsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserThreadCastsError = GetUserThreadCastsErrors[keyof GetUserThreadCastsErrors];
type GetUserThreadCastsResponses = {
    /**
     * Successful retrieval of user thread casts
     */
    200: UserThreadCastsResponse;
};
type GetUserThreadCastsResponse = GetUserThreadCastsResponses[keyof GetUserThreadCastsResponses];
type GetChannelFollowersYouKnowData = {
    body?: never;
    path?: never;
    query: {
        channelKey: string;
        limit?: number;
    };
    url: "/v2/channel-followers-you-know";
};
type GetChannelFollowersYouKnowErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelFollowersYouKnowError = GetChannelFollowersYouKnowErrors[keyof GetChannelFollowersYouKnowErrors];
type GetChannelFollowersYouKnowResponses = {
    /**
     * Successful retrieval of known channel followers
     */
    200: ChannelFollowersYouKnowResponse;
};
type GetChannelFollowersYouKnowResponse = GetChannelFollowersYouKnowResponses[keyof GetChannelFollowersYouKnowResponses];
type MarkAllNotificationsReadData = {
    body: {
        [key: string]: never;
    };
    path?: never;
    query?: never;
    url: "/v2/mark-all-notifications-read";
};
type MarkAllNotificationsReadErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type MarkAllNotificationsReadError = MarkAllNotificationsReadErrors[keyof MarkAllNotificationsReadErrors];
type MarkAllNotificationsReadResponses = {
    /**
     * Successful mark-all-read operation
     */
    200: SuccessResponse;
};
type MarkAllNotificationsReadResponse = MarkAllNotificationsReadResponses[keyof MarkAllNotificationsReadResponses];
type GetNotificationsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Notification tab type
         */
        tab: "all" | "follows" | "reactions" | "mentions" | "replies";
        /**
         * Number of notifications to return
         */
        limit?: number;
    };
    url: "/v1/notifications-for-tab";
};
type GetNotificationsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetNotificationsError = GetNotificationsErrors[keyof GetNotificationsErrors];
type GetNotificationsResponses = {
    /**
     * A list of notifications
     */
    200: NotificationsResponse;
};
type GetNotificationsResponse = GetNotificationsResponses[keyof GetNotificationsResponses];
type SetLastCheckedTimestampData = {
    /**
     * Empty object for now
     */
    body: {
        [key: string]: unknown;
    };
    path?: never;
    query?: never;
    url: "/v2/set-last-checked-timestamp";
};
type SetLastCheckedTimestampErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type SetLastCheckedTimestampError = SetLastCheckedTimestampErrors[keyof SetLastCheckedTimestampErrors];
type SetLastCheckedTimestampResponses = {
    /**
     * Success
     */
    200: SuccessResponse;
};
type SetLastCheckedTimestampResponse = SetLastCheckedTimestampResponses[keyof SetLastCheckedTimestampResponses];
type GetDirectCastConversationData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Conversation ID. Format depends on conversation type:
         * - 1:1 conversations: "fid1-fid2" (e.g., "123-456")
         * - Group conversations: Hash format (e.g., "a1b2c3d4e5f6...")
         *
         */
        conversationId: string;
    };
    url: "/v2/direct-cast-conversation";
};
type GetDirectCastConversationErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetDirectCastConversationError = GetDirectCastConversationErrors[keyof GetDirectCastConversationErrors];
type GetDirectCastConversationResponses = {
    /**
     * A direct cast conversation object
     */
    200: DirectCastConversationResponse;
};
type GetDirectCastConversationResponse = GetDirectCastConversationResponses[keyof GetDirectCastConversationResponses];
type CategorizeDirectCastConversationData = {
    body: DirectCastConversationCategorizationRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-conversation-categorization";
};
type CategorizeDirectCastConversationErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type CategorizeDirectCastConversationError = CategorizeDirectCastConversationErrors[keyof CategorizeDirectCastConversationErrors];
type CategorizeDirectCastConversationResponses = {
    /**
     * Conversation categorized successfully
     */
    200: SuccessResponse;
};
type CategorizeDirectCastConversationResponse = CategorizeDirectCastConversationResponses[keyof CategorizeDirectCastConversationResponses];
type GetDirectCastConversationMessagesData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Conversation ID. Format depends on conversation type:
         * - 1:1 conversations: "fid1-fid2" (e.g., "123-456")
         * - Group conversations: Hash format (e.g., "c9e139dcbc9423cf")
         *
         */
        conversationId: string;
        /**
         * Maximum number of messages to return
         */
        limit?: number;
    };
    url: "/v2/direct-cast-conversation-messages";
};
type GetDirectCastConversationMessagesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetDirectCastConversationMessagesError = GetDirectCastConversationMessagesErrors[keyof GetDirectCastConversationMessagesErrors];
type GetDirectCastConversationMessagesResponses = {
    /**
     * A list of direct cast conversation messages with pagination
     */
    200: DirectCastConversationMessagesResponse;
};
type GetDirectCastConversationMessagesResponse = GetDirectCastConversationMessagesResponses[keyof GetDirectCastConversationMessagesResponses];
type SetDirectCastConversationMessageTtlData = {
    body: DirectCastConversationMessageTtlRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-conversation-message-ttl";
};
type SetDirectCastConversationMessageTtlErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type SetDirectCastConversationMessageTtlError = SetDirectCastConversationMessageTtlErrors[keyof SetDirectCastConversationMessageTtlErrors];
type SetDirectCastConversationMessageTtlResponses = {
    /**
     * Message TTL set successfully
     */
    200: SuccessResponse;
};
type SetDirectCastConversationMessageTtlResponse = SetDirectCastConversationMessageTtlResponses[keyof SetDirectCastConversationMessageTtlResponses];
type UpdateDirectCastConversationNotificationsData = {
    body: DirectCastConversationNotificationsRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-conversation-notifications";
};
type UpdateDirectCastConversationNotificationsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type UpdateDirectCastConversationNotificationsError = UpdateDirectCastConversationNotificationsErrors[keyof UpdateDirectCastConversationNotificationsErrors];
type UpdateDirectCastConversationNotificationsResponses = {
    /**
     * Notification settings updated successfully
     */
    200: SuccessResponse;
};
type UpdateDirectCastConversationNotificationsResponse = UpdateDirectCastConversationNotificationsResponses[keyof UpdateDirectCastConversationNotificationsResponses];
type GetDirectCastConversationRecentMessagesData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Conversation ID. Format depends on conversation type:
         * - 1:1 conversations: "fid1-fid2" (e.g., "123-456")
         * - Group conversations: Hash format (e.g., "c9e139dcbc9423cf")
         *
         */
        conversationId: string;
    };
    url: "/v2/direct-cast-conversation-recent-messages";
};
type GetDirectCastConversationRecentMessagesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetDirectCastConversationRecentMessagesError = GetDirectCastConversationRecentMessagesErrors[keyof GetDirectCastConversationRecentMessagesErrors];
type GetDirectCastConversationRecentMessagesResponses = {
    /**
     * A list of recent direct cast conversation messages
     */
    200: DirectCastConversationMessagesResponse;
};
type GetDirectCastConversationRecentMessagesResponse = GetDirectCastConversationRecentMessagesResponses[keyof GetDirectCastConversationRecentMessagesResponses];
type SendDirectCastMessageData = {
    body: DirectCastSendRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-send";
};
type SendDirectCastMessageErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type SendDirectCastMessageError = SendDirectCastMessageErrors[keyof SendDirectCastMessageErrors];
type SendDirectCastMessageResponses = {
    /**
     * Direct cast message sent successfully
     */
    200: SuccessResponse;
};
type SendDirectCastMessageResponse = SendDirectCastMessageResponses[keyof SendDirectCastMessageResponses];
type DirectCastManuallyMarkUnreadData = {
    body: DirectCastManuallyMarkUnreadRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-manually-mark-unread";
};
type DirectCastManuallyMarkUnreadErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type DirectCastManuallyMarkUnreadError = DirectCastManuallyMarkUnreadErrors[keyof DirectCastManuallyMarkUnreadErrors];
type DirectCastManuallyMarkUnreadResponses = {
    /**
     * Direct cast conversation marked as unread successfully
     */
    200: SuccessResponse;
};
type DirectCastManuallyMarkUnreadResponse = DirectCastManuallyMarkUnreadResponses[keyof DirectCastManuallyMarkUnreadResponses];
type RemoveDirectCastMessageReactionData = {
    body: DirectCastMessageReactionRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-message-reaction";
};
type RemoveDirectCastMessageReactionErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type RemoveDirectCastMessageReactionError = RemoveDirectCastMessageReactionErrors[keyof RemoveDirectCastMessageReactionErrors];
type RemoveDirectCastMessageReactionResponses = {
    /**
     * Reaction removed successfully
     */
    200: SuccessResponse;
};
type RemoveDirectCastMessageReactionResponse = RemoveDirectCastMessageReactionResponses[keyof RemoveDirectCastMessageReactionResponses];
type AddDirectCastMessageReactionData = {
    body: DirectCastMessageReactionRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-message-reaction";
};
type AddDirectCastMessageReactionErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type AddDirectCastMessageReactionError = AddDirectCastMessageReactionErrors[keyof AddDirectCastMessageReactionErrors];
type AddDirectCastMessageReactionResponses = {
    /**
     * Reaction added successfully
     */
    200: SuccessResponse;
};
type AddDirectCastMessageReactionResponse = AddDirectCastMessageReactionResponses[keyof AddDirectCastMessageReactionResponses];
type UnpinDirectCastConversationData = {
    body: DirectCastPinConversationRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-pin-conversation";
};
type UnpinDirectCastConversationErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type UnpinDirectCastConversationError = UnpinDirectCastConversationErrors[keyof UnpinDirectCastConversationErrors];
type UnpinDirectCastConversationResponses = {
    /**
     * Direct cast conversation unpinned successfully
     */
    200: SuccessResponse;
};
type UnpinDirectCastConversationResponse = UnpinDirectCastConversationResponses[keyof UnpinDirectCastConversationResponses];
type PinDirectCastConversationData = {
    body: DirectCastPinConversationRequest;
    path?: never;
    query?: never;
    url: "/v2/direct-cast-pin-conversation";
};
type PinDirectCastConversationErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type PinDirectCastConversationError = PinDirectCastConversationErrors[keyof PinDirectCastConversationErrors];
type PinDirectCastConversationResponses = {
    /**
     * Direct cast conversation pinned successfully
     */
    200: SuccessResponse;
};
type PinDirectCastConversationResponse = PinDirectCastConversationResponses[keyof PinDirectCastConversationResponses];
type DiscoverChannelsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of channels to retrieve
         */
        limit?: number;
    };
    url: "/v2/discover-channels";
};
type DiscoverChannelsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type DiscoverChannelsError = DiscoverChannelsErrors[keyof DiscoverChannelsErrors];
type DiscoverChannelsResponses = {
    /**
     * A list of channels
     */
    200: DiscoverChannelsResponse;
};
type DiscoverChannelsResponse2 = DiscoverChannelsResponses[keyof DiscoverChannelsResponses];
type GetAvailableInvitesData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/invites-available";
};
type GetAvailableInvitesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetAvailableInvitesError = GetAvailableInvitesErrors[keyof GetAvailableInvitesErrors];
type GetAvailableInvitesResponses = {
    /**
     * Invite count information
     */
    200: InvitesAvailableResponse;
};
type GetAvailableInvitesResponse = GetAvailableInvitesResponses[keyof GetAvailableInvitesResponses];
type GetSponsoredInvitesData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/warpcast-sponsored-invites";
};
type GetSponsoredInvitesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetSponsoredInvitesError = GetSponsoredInvitesErrors[keyof GetSponsoredInvitesErrors];
type GetSponsoredInvitesResponses = {
    /**
     * List of sponsored invites
     */
    200: SponsoredInvitesResponse;
};
type GetSponsoredInvitesResponse = GetSponsoredInvitesResponses[keyof GetSponsoredInvitesResponses];
type GetRewardsLeaderboardData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        rewardsType: "invite";
        cursor?: string;
    };
    url: "/v2/rewards-leaderboard";
};
type GetRewardsLeaderboardErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetRewardsLeaderboardError = GetRewardsLeaderboardErrors[keyof GetRewardsLeaderboardErrors];
type GetRewardsLeaderboardResponses = {
    /**
     * Rewards leaderboard
     */
    200: RewardsLeaderboardResponse;
};
type GetRewardsLeaderboardResponse = GetRewardsLeaderboardResponses[keyof GetRewardsLeaderboardResponses];
type GetUserRewardsScoresData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
        rewardsType: "invite";
    };
    url: "/v2/rewards-scores-for-user";
};
type GetUserRewardsScoresErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetUserRewardsScoresError = GetUserRewardsScoresErrors[keyof GetUserRewardsScoresErrors];
type GetUserRewardsScoresResponses = {
    /**
     * User rewards scores
     */
    200: RewardsScoresResponse;
};
type GetUserRewardsScoresResponse = GetUserRewardsScoresResponses[keyof GetUserRewardsScoresResponses];
type GetRewardsMetadataData = {
    body?: never;
    path?: never;
    query: {
        rewardsType: "invite";
    };
    url: "/v2/rewards-metadata";
};
type GetRewardsMetadataErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Too many requests
     */
    429: unknown;
};
type GetRewardsMetadataError = GetRewardsMetadataErrors[keyof GetRewardsMetadataErrors];
type GetRewardsMetadataResponses = {
    /**
     * Invite rewards metadata
     */
    200: RewardsMetadataResponse;
};
type GetRewardsMetadataResponse = GetRewardsMetadataResponses[keyof GetRewardsMetadataResponses];
type GetBookmarkedCastsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
    };
    url: "/v2/bookmarked-casts";
};
type GetBookmarkedCastsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetBookmarkedCastsError = GetBookmarkedCastsErrors[keyof GetBookmarkedCastsErrors];
type GetBookmarkedCastsResponses = {
    /**
     * A list of bookmarked casts
     */
    200: BookmarkedCastsResponse;
};
type GetBookmarkedCastsResponse = GetBookmarkedCastsResponses[keyof GetBookmarkedCastsResponses];
type GetUserStarterPacksData = {
    body?: never;
    path?: never;
    query: {
        fid: number;
        limit?: number;
    };
    url: "/v2/starter-packs";
};
type GetUserStarterPacksErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserStarterPacksError = GetUserStarterPacksErrors[keyof GetUserStarterPacksErrors];
type GetUserStarterPacksResponses = {
    /**
     * A list of starter packs
     */
    200: StarterPacksResponse;
};
type GetUserStarterPacksResponse = GetUserStarterPacksResponses[keyof GetUserStarterPacksResponses];
type GetSuggestedStarterPacksData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
    };
    url: "/v2/starter-packs/suggested";
};
type GetSuggestedStarterPacksErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetSuggestedStarterPacksError = GetSuggestedStarterPacksErrors[keyof GetSuggestedStarterPacksErrors];
type GetSuggestedStarterPacksResponses = {
    /**
     * A list of suggested starter packs
     */
    200: StarterPacksResponse;
};
type GetSuggestedStarterPacksResponse = GetSuggestedStarterPacksResponses[keyof GetSuggestedStarterPacksResponses];
type GetStarterPackData = {
    body?: never;
    path?: never;
    query: {
        id: string;
    };
    url: "/v2/starter-pack";
};
type GetStarterPackErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetStarterPackError = GetStarterPackErrors[keyof GetStarterPackErrors];
type GetStarterPackResponses = {
    /**
     * A starter pack object
     */
    200: StarterPackResponse;
};
type GetStarterPackResponse = GetStarterPackResponses[keyof GetStarterPackResponses];
type UpdateStarterPackData = {
    body: StarterPackUpdateRequest;
    headers?: {
        /**
         * Idempotency key to safely retry the request without performing the operation multiple times.
         */
        "idempotency-key"?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/starter-pack";
};
type UpdateStarterPackErrors = {
    /**
     * Bad request - validation errors or malformed request
     */
    400: BadRequestError;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * The specified resource was not found
     */
    404: ErrorResponse;
};
type UpdateStarterPackError = UpdateStarterPackErrors[keyof UpdateStarterPackErrors];
type UpdateStarterPackResponses = {
    /**
     * Update status
     */
    200: SuccessResponse;
};
type UpdateStarterPackResponse = UpdateStarterPackResponses[keyof UpdateStarterPackResponses];
type GetStarterPackUsersData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        id: string;
    };
    url: "/v2/starter-pack-users";
};
type GetStarterPackUsersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetStarterPackUsersError = GetStarterPackUsersErrors[keyof GetStarterPackUsersErrors];
type GetStarterPackUsersResponses = {
    /**
     * List of users in the starter pack
     */
    200: StarterPackUsersResponse;
};
type GetStarterPackUsersResponse = GetStarterPackUsersResponses[keyof GetStarterPackUsersResponses];
type GetChannelData = {
    body?: never;
    path?: never;
    query: {
        key: string;
    };
    url: "/v2/channel";
};
type GetChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelError = GetChannelErrors[keyof GetChannelErrors];
type GetChannelResponses = {
    /**
     * Channel metadata
     */
    200: ChannelResponse;
};
type GetChannelResponse = GetChannelResponses[keyof GetChannelResponses];
type GetChannelUsersData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        channelKey: string;
        filterToMembers?: boolean;
        query?: string;
    };
    url: "/v1/channel-users";
};
type GetChannelUsersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelUsersError = GetChannelUsersErrors[keyof GetChannelUsersErrors];
type GetChannelUsersResponses = {
    /**
     * A list of users in the specified channel
     */
    200: ChannelUsersResponse;
};
type GetChannelUsersResponse = GetChannelUsersResponses[keyof GetChannelUsersResponses];
type GetFollowingData = {
    body?: never;
    path?: never;
    query: {
        fid: number;
        limit?: number;
    };
    url: "/v2/following";
};
type GetFollowingErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetFollowingError = GetFollowingErrors[keyof GetFollowingErrors];
type GetFollowingResponses = {
    /**
     * A list of followed users
     */
    200: UsersResponse;
};
type GetFollowingResponse = GetFollowingResponses[keyof GetFollowingResponses];
type GetFollowersData = {
    body?: never;
    path?: never;
    query: {
        fid: number;
        limit?: number;
    };
    url: "/v2/followers";
};
type GetFollowersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetFollowersError = GetFollowersErrors[keyof GetFollowersErrors];
type GetFollowersResponses = {
    /**
     * A list of followers
     */
    200: UsersResponse;
};
type GetFollowersResponse = GetFollowersResponses[keyof GetFollowersResponses];
type GetMutualFollowersData = {
    body?: never;
    path?: never;
    query: {
        fid: number;
        limit?: number;
    };
    url: "/v2/followers-you-know";
};
type GetMutualFollowersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetMutualFollowersError = GetMutualFollowersErrors[keyof GetMutualFollowersErrors];
type GetMutualFollowersResponses = {
    /**
     * A list of mutual followers
     */
    200: UsersWithCountResponse;
};
type GetMutualFollowersResponse = GetMutualFollowersResponses[keyof GetMutualFollowersResponses];
type GetTopFrameAppsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        cursor?: string;
    };
    url: "/v1/top-frameapps";
};
type GetTopFrameAppsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetTopFrameAppsError = GetTopFrameAppsErrors[keyof GetTopFrameAppsErrors];
type GetTopFrameAppsResponses = {
    /**
     * A list of FrameApps
     */
    200: FrameAppsResponse;
};
type GetTopFrameAppsResponse = GetTopFrameAppsResponses[keyof GetTopFrameAppsResponses];
type GetTopMiniAppsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        /**
         * Base64 encoded cursor for pagination
         */
        cursor?: string;
    };
    url: "/v1/top-mini-apps";
};
type GetTopMiniAppsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetTopMiniAppsError = GetTopMiniAppsErrors[keyof GetTopMiniAppsErrors];
type GetTopMiniAppsResponses = {
    /**
     * A list of top mini apps
     */
    200: TopMiniAppsResponse;
};
type GetTopMiniAppsResponse = GetTopMiniAppsResponses[keyof GetTopMiniAppsResponses];
type GetVerificationsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
        /**
         * Maximum number of items to return
         */
        limit?: number;
    };
    url: "/v2/verifications";
};
type GetVerificationsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetVerificationsError = GetVerificationsErrors[keyof GetVerificationsErrors];
type GetVerificationsResponses = {
    /**
     * A list of verifications
     */
    200: {
        result?: {
            verifications?: Array<VerifiedAddress>;
        };
    };
};
type GetVerificationsResponse = GetVerificationsResponses[keyof GetVerificationsResponses];
type GetMutedKeywordsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/get-muted-keywords";
};
type GetMutedKeywordsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetMutedKeywordsError = GetMutedKeywordsErrors[keyof GetMutedKeywordsErrors];
type GetMutedKeywordsResponses = {
    /**
     * A list of muted keywords
     */
    200: MutedKeywordsResponse;
};
type GetMutedKeywordsResponse = GetMutedKeywordsResponses[keyof GetMutedKeywordsResponses];
type MuteKeywordData = {
    body: {
        keyword?: string;
        properties?: MutedKeywordProperties;
    };
    path?: never;
    query?: never;
    url: "/v2/mute-keyword";
};
type MuteKeywordErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type MuteKeywordError = MuteKeywordErrors[keyof MuteKeywordErrors];
type MuteKeywordResponses = {
    /**
     * The muted keyword and its settings
     */
    200: MutedKeywordsResponse;
};
type MuteKeywordResponse = MuteKeywordResponses[keyof MuteKeywordResponses];
type UnmuteKeywordData = {
    body: {
        keyword?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/unmute-keyword";
};
type UnmuteKeywordErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UnmuteKeywordError = UnmuteKeywordErrors[keyof UnmuteKeywordErrors];
type UnmuteKeywordResponses = {
    /**
     * Keyword unmuted
     */
    200: MutedKeywordsResponse;
};
type UnmuteKeywordResponse = UnmuteKeywordResponses[keyof UnmuteKeywordResponses];
type UnlikeCastData = {
    body: {
        castHash: string;
    };
    path?: never;
    query?: never;
    url: "/v2/cast-likes";
};
type UnlikeCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UnlikeCastError = UnlikeCastErrors[keyof UnlikeCastErrors];
type UnlikeCastResponses = {
    /**
     * Unlike response
     */
    200: {
        result?: {
            success?: boolean;
        };
    };
};
type UnlikeCastResponse = UnlikeCastResponses[keyof UnlikeCastResponses];
type GetCastLikesData = {
    body?: never;
    path?: never;
    query: {
        castHash: string;
        limit?: number;
    };
    url: "/v2/cast-likes";
};
type GetCastLikesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetCastLikesError = GetCastLikesErrors[keyof GetCastLikesErrors];
type GetCastLikesResponses = {
    /**
     * A list of cast likes
     */
    200: {
        result?: {
            likes?: Array<{
                type?: string;
                hash?: string;
                castHash?: string;
                timestamp?: number;
                reactor?: User;
            }>;
        };
    };
};
type GetCastLikesResponse = GetCastLikesResponses[keyof GetCastLikesResponses];
type LikeCastData = {
    body: {
        castHash: string;
    };
    path?: never;
    query?: never;
    url: "/v2/cast-likes";
};
type LikeCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type LikeCastError = LikeCastErrors[keyof LikeCastErrors];
type LikeCastResponses = {
    /**
     * Like response
     */
    200: {
        result?: {
            like?: {
                type?: string;
                hash?: string;
                castHash?: string;
                timestamp?: number;
                reactor?: User;
            };
        };
    };
};
type LikeCastResponse = LikeCastResponses[keyof LikeCastResponses];
type UndoRecastData = {
    body: {
        castHash: string;
    };
    path?: never;
    query?: never;
    url: "/v2/recasts";
};
type UndoRecastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UndoRecastError = UndoRecastErrors[keyof UndoRecastErrors];
type UndoRecastResponses = {
    /**
     * Undo recast response
     */
    200: SuccessResponse;
};
type UndoRecastResponse = UndoRecastResponses[keyof UndoRecastResponses];
type RecastCastData = {
    body: {
        castHash: string;
    };
    path?: never;
    query?: never;
    url: "/v2/recasts";
};
type RecastCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type RecastCastError = RecastCastErrors[keyof RecastCastErrors];
type RecastCastResponses = {
    /**
     * Recast response
     */
    200: CastHashResponse;
};
type RecastCastResponse = RecastCastResponses[keyof RecastCastResponses];
type AttachEmbedsData = {
    body: {
        text?: string;
        embeds?: Array<string>;
    };
    path?: never;
    query?: never;
    url: "/v2/cast-attachments";
};
type AttachEmbedsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type AttachEmbedsError = AttachEmbedsErrors[keyof AttachEmbedsErrors];
type AttachEmbedsResponses = {
    /**
     * Attachment response
     */
    200: AttachEmbedsResponse;
};
type AttachEmbedsResponse2 = AttachEmbedsResponses[keyof AttachEmbedsResponses];
type GetCastRecastersData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        castHash: string;
    };
    url: "/v2/cast-recasters";
};
type GetCastRecastersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetCastRecastersError = GetCastRecastersErrors[keyof GetCastRecastersErrors];
type GetCastRecastersResponses = {
    /**
     * A list of users who recasted the cast
     */
    200: CastRecastersResponse;
};
type GetCastRecastersResponse = GetCastRecastersResponses[keyof GetCastRecastersResponses];
type GetCastQuotesData = {
    body?: never;
    path?: never;
    query: {
        castHash: string;
        limit?: number;
    };
    url: "/v2/cast-quotes";
};
type GetCastQuotesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetCastQuotesError = GetCastQuotesErrors[keyof GetCastQuotesErrors];
type GetCastQuotesResponses = {
    /**
     * A list of quote casts referencing the given cast
     */
    200: CastQuotesResponse;
};
type GetCastQuotesResponse = GetCastQuotesResponses[keyof GetCastQuotesResponses];
type GetCurrentUserData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/me";
};
type GetCurrentUserErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetCurrentUserError = GetCurrentUserErrors[keyof GetCurrentUserErrors];
type GetCurrentUserResponses = {
    /**
     * Successful retrieval of current user
     */
    200: UserResponseUserResponse;
};
type GetCurrentUserResponse = GetCurrentUserResponses[keyof GetCurrentUserResponses];
type SearchChannelsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of items to return
         */
        limit?: number;
        q?: string;
        prioritizeFollowed?: boolean;
        forComposer?: boolean;
    };
    url: "/v2/search-channels";
};
type SearchChannelsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type SearchChannelsError = SearchChannelsErrors[keyof SearchChannelsErrors];
type SearchChannelsResponses = {
    /**
     * A list of matched channels
     */
    200: SearchChannelsResponse;
};
type SearchChannelsResponse2 = SearchChannelsResponses[keyof SearchChannelsResponses];
type GetDraftCastsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
    };
    url: "/v2/draft-caststorms";
};
type GetDraftCastsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetDraftCastsError = GetDraftCastsErrors[keyof GetDraftCastsErrors];
type GetDraftCastsResponses = {
    /**
     * A list of draft cast storms
     */
    200: DraftsResponse;
};
type GetDraftCastsResponse = GetDraftCastsResponses[keyof GetDraftCastsResponses];
type CreateDraftCastsData = {
    body: {
        caststorm?: {
            casts?: Array<DraftCast>;
        };
    };
    headers: {
        "idempotency-key": string;
    };
    path?: never;
    query?: never;
    url: "/v2/draft-caststorms";
};
type CreateDraftCastsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type CreateDraftCastsError = CreateDraftCastsErrors[keyof CreateDraftCastsErrors];
type CreateDraftCastsResponses = {
    /**
     * Created draft caststorm
     */
    200: DraftCreatedResponse;
};
type CreateDraftCastsResponse = CreateDraftCastsResponses[keyof CreateDraftCastsResponses];
type DeleteDraftCastData = {
    body: {
        draftId?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/draft-casts";
};
type DeleteDraftCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type DeleteDraftCastError = DeleteDraftCastErrors[keyof DeleteDraftCastErrors];
type DeleteDraftCastResponses = {
    /**
     * Draft cast deleted
     */
    200: SuccessResponse;
};
type DeleteDraftCastResponse = DeleteDraftCastResponses[keyof DeleteDraftCastResponses];
type DeleteCastData = {
    body: {
        castHash?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/casts";
};
type DeleteCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type DeleteCastError = DeleteCastErrors[keyof DeleteCastErrors];
type DeleteCastResponses = {
    /**
     * Cast deleted successfully
     */
    200: SuccessResponse;
};
type DeleteCastResponse = DeleteCastResponses[keyof DeleteCastResponses];
type GetCastsByFidData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The FID (Farcaster ID) of the user whose casts to retrieve
         */
        fid: number;
        /**
         * Maximum number of casts to return
         */
        limit?: number;
    };
    url: "/v2/casts";
};
type GetCastsByFidErrors = {
    /**
     * Bad request
     */
    400: ErrorResponse;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetCastsByFidError = GetCastsByFidErrors[keyof GetCastsByFidErrors];
type GetCastsByFidResponses = {
    /**
     * Successfully retrieved casts
     */
    200: {
        result?: {
            casts?: Array<Cast>;
        };
    };
};
type GetCastsByFidResponse = GetCastsByFidResponses[keyof GetCastsByFidResponses];
type CreateCastData = {
    body: {
        text: string;
        embeds?: Array<unknown>;
        /**
         * Optional channel to post the cast to
         */
        channelKey?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/casts";
};
type CreateCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type CreateCastError = CreateCastErrors[keyof CreateCastErrors];
type CreateCastResponses = {
    /**
     * Cast created successfully
     */
    200: CastCreatedResponse;
};
type CreateCastResponse = CreateCastResponses[keyof CreateCastResponses];
type GetAllChannelsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/all-channels";
};
type GetAllChannelsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetAllChannelsError = GetAllChannelsErrors[keyof GetAllChannelsErrors];
type GetAllChannelsResponses = {
    /**
     * Successful response
     */
    200: ChannelListResponse;
};
type GetAllChannelsResponse = GetAllChannelsResponses[keyof GetAllChannelsResponses];
type GetChannelDetailsData = {
    body?: never;
    path?: never;
    query: {
        channelId: string;
    };
    url: "/v1/channel";
};
type GetChannelDetailsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelDetailsError = GetChannelDetailsErrors[keyof GetChannelDetailsErrors];
type GetChannelDetailsResponses = {
    /**
     * Channel details
     */
    200: RawChannelResponse;
};
type GetChannelDetailsResponse = GetChannelDetailsResponses[keyof GetChannelDetailsResponses];
type GetChannelFollowersData = {
    body?: never;
    path?: never;
    query: {
        channelId: string;
        cursor?: string;
    };
    url: "/v1/channel-followers";
};
type GetChannelFollowersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelFollowersError = GetChannelFollowersErrors[keyof GetChannelFollowersErrors];
type GetChannelFollowersResponses = {
    /**
     * A list of channel followers
     */
    200: ChannelFollowersResponse;
};
type GetChannelFollowersResponse = GetChannelFollowersResponses[keyof GetChannelFollowersResponses];
type GetUserFollowedChannelsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
    };
    url: "/v1/user-following-channels";
};
type GetUserFollowedChannelsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserFollowedChannelsError = GetUserFollowedChannelsErrors[keyof GetUserFollowedChannelsErrors];
type GetUserFollowedChannelsResponses = {
    /**
     * Successful response with list of followed channels
     */
    200: ChannelListResponse;
};
type GetUserFollowedChannelsResponse = GetUserFollowedChannelsResponses[keyof GetUserFollowedChannelsResponses];
type CheckUserChannelFollowStatusData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
        channelId: string;
    };
    url: "/v1/user-channel";
};
type CheckUserChannelFollowStatusErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type CheckUserChannelFollowStatusError = CheckUserChannelFollowStatusErrors[keyof CheckUserChannelFollowStatusErrors];
type CheckUserChannelFollowStatusResponses = {
    /**
     * Successful response with follow status
     */
    200: ChannelFollowStatusResponse;
};
type CheckUserChannelFollowStatusResponse = CheckUserChannelFollowStatusResponses[keyof CheckUserChannelFollowStatusResponses];
type GetChannelMembersData = {
    body?: never;
    path?: never;
    query: {
        channelId: string;
    };
    url: "/fc/channel-members";
};
type GetChannelMembersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelMembersError = GetChannelMembersErrors[keyof GetChannelMembersErrors];
type GetChannelMembersResponses = {
    /**
     * Successful response with list of members
     */
    200: {
        result: {
            members: Array<{
                /**
                 * Farcaster ID of the member
                 */
                fid: number;
                /**
                 * Timestamp when the user became a member
                 */
                memberAt: number;
            }>;
        };
        next?: {
            /**
             * Cursor for pagination
             */
            cursor?: string;
        };
    };
};
type GetChannelMembersResponse = GetChannelMembersResponses[keyof GetChannelMembersResponses];
type RemoveChannelInviteData = {
    body: {
        /**
         * ID of the channel from which the user's invite is being removed
         */
        channelId: string;
        /**
         * Farcaster ID of the user whose invite is being removed
         */
        removeFid: number;
        /**
         * Role associated with the invite being removed
         */
        role: "member" | "admin";
    };
    path?: never;
    query?: never;
    url: "/fc/channel-invites";
};
type RemoveChannelInviteErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type RemoveChannelInviteError = RemoveChannelInviteErrors[keyof RemoveChannelInviteErrors];
type RemoveChannelInviteResponses = {
    /**
     * Successful removal of invite
     */
    200: SuccessResponse;
};
type RemoveChannelInviteResponse = RemoveChannelInviteResponses[keyof RemoveChannelInviteResponses];
type GetChannelInvitesData = {
    body?: never;
    path?: never;
    query: {
        channelId: string;
    };
    url: "/fc/channel-invites";
};
type GetChannelInvitesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelInvitesError = GetChannelInvitesErrors[keyof GetChannelInvitesErrors];
type GetChannelInvitesResponses = {
    /**
     * Successful response with list of channel invites
     */
    200: {
        result?: {
            invites?: Array<{
                channelId: string;
                invitedFid: number;
                invitedAt: number;
                inviterFid: number;
                role: "member" | "admin";
            }>;
        };
        next?: {
            cursor?: string;
        };
    };
};
type GetChannelInvitesResponse = GetChannelInvitesResponses[keyof GetChannelInvitesResponses];
type AcceptChannelInviteData = {
    body: {
        /**
         * ID of the channel for which the invite is being accepted
         */
        channelId: string;
        /**
         * Role that the user will have in the channel
         */
        role: "member" | "admin";
        /**
         * Flag indicating whether to accept the invite
         */
        accept: boolean;
    };
    path?: never;
    query?: never;
    url: "/fc/channel-invites";
};
type AcceptChannelInviteErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type AcceptChannelInviteError = AcceptChannelInviteErrors[keyof AcceptChannelInviteErrors];
type AcceptChannelInviteResponses = {
    /**
     * Successful acceptance of invite
     */
    200: SuccessResponse;
};
type AcceptChannelInviteResponse = AcceptChannelInviteResponses[keyof AcceptChannelInviteResponses];
type InviteUserToChannelData = {
    body: {
        /**
         * ID of the channel to invite the user to
         */
        channelId: string;
        /**
         * Farcaster ID of the user being invited
         */
        inviteFid: number;
        /**
         * Role of the invited user within the channel
         */
        role: "member" | "admin";
    };
    path?: never;
    query?: never;
    url: "/fc/channel-invites";
};
type InviteUserToChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type InviteUserToChannelError = InviteUserToChannelErrors[keyof InviteUserToChannelErrors];
type InviteUserToChannelResponses = {
    /**
     * Successful invite operation
     */
    200: SuccessResponse;
};
type InviteUserToChannelResponse = InviteUserToChannelResponses[keyof InviteUserToChannelResponses];
type GetChannelModeratedCastsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * ID of the channel to get moderation actions for
         */
        channelId: string;
    };
    url: "/fc/moderated-casts";
};
type GetChannelModeratedCastsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelModeratedCastsError = GetChannelModeratedCastsErrors[keyof GetChannelModeratedCastsErrors];
type GetChannelModeratedCastsResponses = {
    /**
     * Successful response with list of moderation actions
     */
    200: {
        result: {
            moderationActions: Array<{
                /**
                 * Hash of the moderated cast
                 */
                castHash: string;
                /**
                 * ID of the channel where the cast was moderated
                 */
                channelId: string;
                /**
                 * Type of moderation action applied
                 */
                action: "hide";
                /**
                 * Unix timestamp of when the moderation action was taken
                 */
                moderatedAt: number;
            }>;
        };
        next?: {
            /**
             * Pagination cursor for fetching the next set of results
             */
            cursor?: string;
        };
    };
};
type GetChannelModeratedCastsResponse = GetChannelModeratedCastsResponses[keyof GetChannelModeratedCastsResponses];
type GetChannelRestrictedUsersData = {
    body?: never;
    path?: never;
    query: {
        /**
         * ID of the channel to get restricted users for
         */
        channelId: string;
    };
    url: "/fc/channel-restricted-users";
};
type GetChannelRestrictedUsersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelRestrictedUsersError = GetChannelRestrictedUsersErrors[keyof GetChannelRestrictedUsersErrors];
type GetChannelRestrictedUsersResponses = {
    /**
     * Successful response with list of restricted users
     */
    200: {
        result: {
            restrictedUsers: Array<{
                /**
                 * Farcaster ID of the restricted user
                 */
                fid: number;
                /**
                 * ID of the channel where the user is restricted
                 */
                channelId: string;
                /**
                 * Unix timestamp of when the user was restricted
                 */
                restrictedAt: number;
            }>;
        };
        next?: {
            /**
             * Pagination cursor for fetching the next set of results
             */
            cursor?: string;
        };
    };
};
type GetChannelRestrictedUsersResponse = GetChannelRestrictedUsersResponses[keyof GetChannelRestrictedUsersResponses];
type UnbanUserFromChannelData = {
    body: {
        /**
         * ID of the channel from which to unban the user
         */
        channelId: string;
        /**
         * Farcaster ID of the user to unban
         */
        banFid: number;
    };
    path?: never;
    query?: never;
    url: "/fc/channel-bans";
};
type UnbanUserFromChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UnbanUserFromChannelError = UnbanUserFromChannelErrors[keyof UnbanUserFromChannelErrors];
type UnbanUserFromChannelResponses = {
    /**
     * Successful unban operation
     */
    200: SuccessResponse;
};
type UnbanUserFromChannelResponse = UnbanUserFromChannelResponses[keyof UnbanUserFromChannelResponses];
type GetChannelBannedUsersData = {
    body?: never;
    path?: never;
    query: {
        /**
         * ID of the channel to get banned users for
         */
        channelId: string;
    };
    url: "/fc/channel-bans";
};
type GetChannelBannedUsersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetChannelBannedUsersError = GetChannelBannedUsersErrors[keyof GetChannelBannedUsersErrors];
type GetChannelBannedUsersResponses = {
    /**
     * Successful response with list of banned users
     */
    200: {
        result: {
            bannedUsers: Array<{
                /**
                 * Farcaster ID of the banned user
                 */
                fid: number;
                /**
                 * ID of the channel where the user is banned
                 */
                channelId: string;
                /**
                 * Unix timestamp of when the user was banned
                 */
                bannedAt: number;
            }>;
        };
        next?: {
            /**
             * Pagination cursor for fetching the next set of banned users
             */
            cursor?: string;
        };
    };
};
type GetChannelBannedUsersResponse = GetChannelBannedUsersResponses[keyof GetChannelBannedUsersResponses];
type BanUserFromChannelData = {
    body: {
        /**
         * ID of the channel from which to ban the user
         */
        channelId: string;
        /**
         * Farcaster ID of the user to ban
         */
        banFid: number;
    };
    path?: never;
    query?: never;
    url: "/fc/channel-bans";
};
type BanUserFromChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type BanUserFromChannelError = BanUserFromChannelErrors[keyof BanUserFromChannelErrors];
type BanUserFromChannelResponses = {
    /**
     * Successful ban operation
     */
    200: SuccessResponse;
};
type BanUserFromChannelResponse = BanUserFromChannelResponses[keyof BanUserFromChannelResponses];
type UnfollowChannelData = {
    body: {
        /**
         * ID of the channel to unfollow
         */
        channelId: string;
    };
    path?: never;
    query?: never;
    url: "/fc/channel-follows";
};
type UnfollowChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UnfollowChannelError = UnfollowChannelErrors[keyof UnfollowChannelErrors];
type UnfollowChannelResponses = {
    /**
     * Successful unfollow operation
     */
    200: SuccessResponse;
};
type UnfollowChannelResponse = UnfollowChannelResponses[keyof UnfollowChannelResponses];
type FollowChannelData = {
    body: {
        /**
         * ID of the channel to follow
         */
        channelId: string;
    };
    path?: never;
    query?: never;
    url: "/fc/channel-follows";
};
type FollowChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type FollowChannelError = FollowChannelErrors[keyof FollowChannelErrors];
type FollowChannelResponses = {
    /**
     * Successful follow operation
     */
    200: SuccessResponse;
};
type FollowChannelResponse = FollowChannelResponses[keyof FollowChannelResponses];
type ModerateCastData = {
    body: {
        /**
         * Hash of the cast to moderate
         */
        castHash: string;
        /**
         * Type of moderation action to apply
         */
        action: "hide";
    };
    path?: never;
    query?: never;
    url: "/fc/moderate-cast";
};
type ModerateCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type ModerateCastError = ModerateCastErrors[keyof ModerateCastErrors];
type ModerateCastResponses = {
    /**
     * Successful moderation action
     */
    200: SuccessResponse;
};
type ModerateCastResponse = ModerateCastResponses[keyof ModerateCastResponses];
type UnpinCastFromChannelData = {
    body: {
        /**
         * ID of the channel from which to unpin a cast
         */
        channelId: string;
    };
    path?: never;
    query?: never;
    url: "/fc/pinned-casts";
};
type UnpinCastFromChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UnpinCastFromChannelError = UnpinCastFromChannelErrors[keyof UnpinCastFromChannelErrors];
type UnpinCastFromChannelResponses = {
    /**
     * Successful unpin operation
     */
    200: SuccessResponse;
};
type UnpinCastFromChannelResponse = UnpinCastFromChannelResponses[keyof UnpinCastFromChannelResponses];
type PinCastToChannelData = {
    body: {
        /**
         * Hash of the cast to pin
         */
        castHash: string;
        /**
         * Whether to notify followers of the channel about the pin
         */
        notifyChannelFollowers?: boolean;
    };
    path?: never;
    query?: never;
    url: "/fc/pinned-casts";
};
type PinCastToChannelErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type PinCastToChannelError = PinCastToChannelErrors[keyof PinCastToChannelErrors];
type PinCastToChannelResponses = {
    /**
     * Successful pin operation
     */
    200: SuccessResponse;
};
type PinCastToChannelResponse = PinCastToChannelResponses[keyof PinCastToChannelResponses];
type GetDiscoverableActionsData = {
    body?: never;
    path?: never;
    query: {
        list: string;
        limit?: number;
    };
    url: "/v2/discover-actions";
};
type GetDiscoverableActionsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetDiscoverableActionsError = GetDiscoverableActionsErrors[keyof GetDiscoverableActionsErrors];
type GetDiscoverableActionsResponses = {
    /**
     * Successful response with list of discoverable actions
     */
    200: {
        result?: {
            actions?: Array<Action>;
            next?: {
                cursor?: string;
            };
        };
    };
};
type GetDiscoverableActionsResponse = GetDiscoverableActionsResponses[keyof GetDiscoverableActionsResponses];
type GetDiscoverableComposerActionsData = {
    body?: never;
    path?: never;
    query: {
        list: string;
        limit?: number;
    };
    url: "/v2/discover-composer-actions";
};
type GetDiscoverableComposerActionsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetDiscoverableComposerActionsError = GetDiscoverableComposerActionsErrors[keyof GetDiscoverableComposerActionsErrors];
type GetDiscoverableComposerActionsResponses = {
    /**
     * Successful response with list of discoverable composer actions
     */
    200: {
        result?: {
            actions?: Array<Action>;
            next?: {
                cursor?: string;
            };
        };
    };
};
type GetDiscoverableComposerActionsResponse = GetDiscoverableComposerActionsResponses[keyof GetDiscoverableComposerActionsResponses];
type UnblockUserData = {
    body: {
        /**
         * Farcaster ID of the user to unblock
         */
        unblockFid: number;
    };
    path?: never;
    query?: never;
    url: "/fc/blocked-users";
};
type UnblockUserErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type UnblockUserError = UnblockUserErrors[keyof UnblockUserErrors];
type UnblockUserResponses = {
    /**
     * Successful unblock operation
     */
    200: {
        result: {
            /**
             * Indicates whether the unblock operation was successful
             */
            success: boolean;
        };
    };
};
type UnblockUserResponse = UnblockUserResponses[keyof UnblockUserResponses];
type GetBlockedUsersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/fc/blocked-users";
};
type GetBlockedUsersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetBlockedUsersError = GetBlockedUsersErrors[keyof GetBlockedUsersErrors];
type GetBlockedUsersResponses = {
    /**
     * Successful response with list of blocked users
     */
    200: {
        result: {
            blockedUsers: Array<{
                /**
                 * Farcaster ID of the user who blocked
                 */
                blockerFid: number;
                /**
                 * Farcaster ID of the user who was blocked
                 */
                blockedFid: number;
                /**
                 * Unix timestamp of when the user was blocked
                 */
                createdAt: number;
            }>;
            next?: PaginationCursor;
        };
    };
};
type GetBlockedUsersResponse = GetBlockedUsersResponses[keyof GetBlockedUsersResponses];
type BlockUserData = {
    body: {
        /**
         * Farcaster ID of the user to block
         */
        blockFid: number;
    };
    path?: never;
    query?: never;
    url: "/fc/blocked-users";
};
type BlockUserErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type BlockUserError = BlockUserErrors[keyof BlockUserErrors];
type BlockUserResponses = {
    /**
     * Successful block operation
     */
    200: SuccessResponse;
};
type BlockUserResponse = BlockUserResponses[keyof BlockUserResponses];
type GetAccountVerificationsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
    };
    url: "/fc/account-verifications";
};
type GetAccountVerificationsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetAccountVerificationsError = GetAccountVerificationsErrors[keyof GetAccountVerificationsErrors];
type GetAccountVerificationsResponses = {
    /**
     * Successful response with list of account verifications
     */
    200: {
        result?: {
            verifications?: Array<{
                fid?: number;
                platform?: string;
                platformId?: string;
                platformUsername?: string;
                verifiedAt?: number;
            }>;
        };
        next?: PaginationCursor;
    };
};
type GetAccountVerificationsResponse = GetAccountVerificationsResponses[keyof GetAccountVerificationsResponses];
type GetCreatorRewardWinnersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * How many periods ago to fetch the results for. 0 or undefined returns results for the most recent period.
         */
        periodsAgo?: number;
    };
    url: "/v1/creator-rewards-winner-history";
};
type GetCreatorRewardWinnersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetCreatorRewardWinnersError = GetCreatorRewardWinnersErrors[keyof GetCreatorRewardWinnersErrors];
type GetCreatorRewardWinnersResponses = {
    /**
     * Successful response with creator reward winners history
     */
    200: {
        result?: {
            periodStartTimestamp?: bigint;
            periodEndTimestamp?: bigint;
            winners?: Array<{
                fid?: number;
                score?: number;
                rank?: number;
                rewardCents?: number;
                walletAddress?: string;
            }>;
        };
        next?: {
            cursor?: string;
        };
    };
};
type GetCreatorRewardWinnersResponse = GetCreatorRewardWinnersResponses[keyof GetCreatorRewardWinnersResponses];
type GetUserPrimaryAddressData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
        /**
         * The protocol of the address to fetch.
         */
        protocol: "ethereum" | "solana";
    };
    url: "/fc/primary-address";
};
type GetUserPrimaryAddressErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserPrimaryAddressError = GetUserPrimaryAddressErrors[keyof GetUserPrimaryAddressErrors];
type GetUserPrimaryAddressResponses = {
    /**
     * Successful response with the user's primary address.
     */
    200: {
        result?: {
            address?: VerifiedAddress;
        };
    };
};
type GetUserPrimaryAddressResponse = GetUserPrimaryAddressResponses[keyof GetUserPrimaryAddressResponses];
type GetUserPrimaryAddressesData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Comma-separated list of FIDs to fetch primary addresses for.
         */
        fids: string;
        /**
         * The protocol of the addresses to fetch.
         */
        protocol: "ethereum" | "solana";
    };
    url: "/fc/primary-addresses";
};
type GetUserPrimaryAddressesErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetUserPrimaryAddressesError = GetUserPrimaryAddressesErrors[keyof GetUserPrimaryAddressesErrors];
type GetUserPrimaryAddressesResponses = {
    /**
     * Successful response with list of primary addresses.
     */
    200: {
        result?: {
            addresses?: Array<{
                /**
                 * The Farcaster ID of the user
                 */
                fid: number;
                /**
                 * Whether the address was successfully retrieved
                 */
                success: boolean;
                /**
                 * Present only if success is true
                 */
                address?: VerifiedAddress;
            }>;
        };
    };
};
type GetUserPrimaryAddressesResponse = GetUserPrimaryAddressesResponses[keyof GetUserPrimaryAddressesResponses];
type GetStarterPackMembersData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Starter pack ID, as found in the public Warpcast pack URL or in the non-authed public API of starter pack metadata.
         *
         */
        id: string;
    };
    url: "/fc/starter-pack-members";
};
type GetStarterPackMembersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetStarterPackMembersError = GetStarterPackMembersErrors[keyof GetStarterPackMembersErrors];
type GetStarterPackMembersResponses = {
    /**
     * Successful response with list of starter pack members.
     */
    200: {
        result?: {
            members?: Array<{
                /**
                 * The Farcaster ID of the starter pack member
                 */
                fid: number;
                /**
                 * Timestamp in milliseconds when the user became a member
                 */
                memberAt: bigint;
            }>;
        };
        next?: {
            /**
             * Pagination cursor for fetching the next set of results
             */
            cursor?: string;
        };
    };
};
type GetStarterPackMembersResponse = GetStarterPackMembersResponses[keyof GetStarterPackMembersResponses];
type SendDirectCastData = {
    body: {
        /**
         * The Farcaster ID of the recipient.
         */
        recipientFid: number;
        /**
         * The direct cast message.
         */
        message: string;
        /**
         * A unique key to ensure idempotency.
         */
        idempotencyKey: string;
    };
    path?: never;
    query?: never;
    url: "/v2/ext-send-direct-cast";
};
type SendDirectCastErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type SendDirectCastError = SendDirectCastErrors[keyof SendDirectCastErrors];
type SendDirectCastResponses = {
    /**
     * Direct cast sent successfully
     */
    200: {
        result: {
            /**
             * Indicates if the direct cast was sent successfully
             */
            success: boolean;
        };
    };
};
type SendDirectCastResponse = SendDirectCastResponses[keyof SendDirectCastResponses];
type GetUserByVerificationAddressData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Ethereum address used for user verification
         */
        address: string;
    };
    url: "/v2/user-by-verification";
};
type GetUserByVerificationAddressErrors = {
    /**
     * Bad request - validation errors or malformed request
     */
    400: BadRequestError;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * The specified resource was not found
     */
    404: ErrorResponse;
};
type GetUserByVerificationAddressError = GetUserByVerificationAddressErrors[keyof GetUserByVerificationAddressErrors];
type GetUserByVerificationAddressResponses = {
    /**
     * User data successfully retrieved
     */
    200: UserResponse;
};
type GetUserByVerificationAddressResponse = GetUserByVerificationAddressResponses[keyof GetUserByVerificationAddressResponses];
type GetDeveloperRewardWinnersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * How many periods ago to fetch the results for. 0 or undefined returns results for the most recent period.
         */
        periodsAgo?: number;
    };
    url: "/v1/developer-rewards-winner-history";
};
type GetDeveloperRewardWinnersErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetDeveloperRewardWinnersError = GetDeveloperRewardWinnersErrors[keyof GetDeveloperRewardWinnersErrors];
type GetDeveloperRewardWinnersResponses = {
    /**
     * A paginated list of developer reward winners
     */
    200: {
        result?: {
            /**
             * Unix time in milliseconds when rewards period began
             */
            periodStartTimestamp?: number;
            /**
             * Unix time in milliseconds when rewards period ended
             */
            periodEndTimestamp?: number;
            winners?: Array<Winner>;
        };
        next?: {
            /**
             * Pagination cursor for the next set of results
             */
            cursor?: string;
        };
    };
};
type GetDeveloperRewardWinnersResponse = GetDeveloperRewardWinnersResponses[keyof GetDeveloperRewardWinnersResponses];
type GetAppsByAuthorData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's FID (Farcaster ID)
         */
        fid: number;
        /**
         * Maximum number of items to return
         */
        limit?: number;
    };
    url: "/v1/apps-by-author";
};
type GetAppsByAuthorErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetAppsByAuthorError = GetAppsByAuthorErrors[keyof GetAppsByAuthorErrors];
type GetAppsByAuthorResponses = {
    /**
     * A list of frames by the author
     */
    200: AppsByAuthorResponse;
};
type GetAppsByAuthorResponse = GetAppsByAuthorResponses[keyof GetAppsByAuthorResponses];
type GetDomainManifestData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The domain to retrieve manifest information for
         */
        domain: string;
    };
    url: "/v1/domain-manifest";
};
type GetDomainManifestErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetDomainManifestError = GetDomainManifestErrors[keyof GetDomainManifestErrors];
type GetDomainManifestResponses = {
    /**
     * Successfully retrieved domain manifest
     */
    200: {
        result?: {
            state?: {
                /**
                 * Indicates if the domain is verified
                 */
                verified?: boolean;
                /**
                 * JSON string containing the raw manifest data
                 */
                manifest?: string;
                decodedManifest?: {
                    accountAssociation?: {
                        /**
                         * Farcaster ID associated with the domain
                         */
                        fid?: number;
                        /**
                         * Public key associated with the domain
                         */
                        key?: string;
                        /**
                         * The domain name
                         */
                        domain?: string;
                        /**
                         * Signature proving domain ownership
                         */
                        signature?: string;
                    };
                };
                /**
                 * Configuration for Farcaster Frames
                 */
                frameConfig?: {
                    /**
                     * Name of the Frame
                     */
                    name?: string;
                    /**
                     * Version of the Frame
                     */
                    version?: string;
                    /**
                     * URL to the Frame's icon
                     */
                    iconUrl?: string;
                    /**
                     * Home URL of the Frame
                     */
                    homeUrl?: string;
                    /**
                     * Image URL for the Frame
                     */
                    imageUrl?: string;
                    /**
                     * Title for the Frame's button
                     */
                    buttonTitle?: string;
                    /**
                     * URL for the splash image
                     */
                    splashImageUrl?: string;
                    /**
                     * Background color for splash screen
                     */
                    splashBackgroundColor?: string;
                    /**
                     * Webhook URL for the Frame
                     */
                    webhookUrl?: string;
                };
                /**
                 * Timestamp of when the data was last updated
                 */
                updatedAt?: number;
            };
        };
    };
};
type GetDomainManifestResponse = GetDomainManifestResponses[keyof GetDomainManifestResponses];
type GetMetaTagsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The URL to fetch metadata from
         */
        url: string;
    };
    url: "/v1/dev-tools/meta-tags";
};
type GetMetaTagsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetMetaTagsError = GetMetaTagsErrors[keyof GetMetaTagsErrors];
type GetMetaTagsResponses = {
    /**
     * Successfully retrieved metadata
     */
    200: {
        /**
         * Viewport meta tag content
         */
        viewport?: string;
        /**
         * Theme color values
         */
        "theme-color"?: Array<string>;
        /**
         * Color scheme preference
         */
        "color-scheme"?: string;
        /**
         * Page description
         */
        description?: string;
        /**
         * Apple mobile web app capability setting
         */
        "apple-mobile-web-app-capable"?: string;
        /**
         * Apple mobile web app title
         */
        "apple-mobile-web-app-title"?: string;
        /**
         * Apple mobile status bar style
         */
        "apple-mobile-web-app-status-bar-style"?: string;
        /**
         * Open Graph title
         */
        "og:title"?: string;
        /**
         * Open Graph description
         */
        "og:description"?: string;
        /**
         * Open Graph URL
         */
        "og:url"?: string;
        /**
         * Open Graph site name
         */
        "og:site_name"?: string;
        /**
         * Open Graph image alt text
         */
        "og:image:alt"?: string;
        /**
         * Open Graph image MIME type
         */
        "og:image:type"?: string;
        /**
         * Open Graph image width
         */
        "og:image:width"?: string;
        /**
         * Open Graph image height
         */
        "og:image:height"?: string;
        /**
         * Open Graph image URL
         */
        "og:image"?: string;
        /**
         * Open Graph content type
         */
        "og:type"?: string;
        /**
         * Twitter card type
         */
        "twitter:card"?: string;
        /**
         * Twitter card title
         */
        "twitter:title"?: string;
        /**
         * Twitter card description
         */
        "twitter:description"?: string;
        /**
         * Twitter image alt text
         */
        "twitter:image:alt"?: string;
        /**
         * Twitter image MIME type
         */
        "twitter:image:type"?: string;
        /**
         * Twitter image width
         */
        "twitter:image:width"?: string;
        /**
         * Twitter image height
         */
        "twitter:image:height"?: string;
        /**
         * Twitter image URL
         */
        "twitter:image"?: string;
    };
};
type GetMetaTagsResponse = GetMetaTagsResponses[keyof GetMetaTagsResponses];
type GetFarcasterJsonData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The domain to fetch Farcaster JSON data from
         */
        domain: string;
    };
    url: "/v1/dev-tools/farcaster-json";
};
type GetFarcasterJsonErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetFarcasterJsonError = GetFarcasterJsonErrors[keyof GetFarcasterJsonErrors];
type GetFarcasterJsonResponses = {
    /**
     * Successfully retrieved Farcaster JSON data
     */
    200: {
        /**
         * Farcaster account association information
         */
        accountAssociation?: {
            /**
             * Base64 encoded header containing FID, type, and key information
             */
            header?: string;
            /**
             * Base64 encoded payload containing domain information
             */
            payload?: string;
            /**
             * Cryptographic signature for verification
             */
            signature?: string;
        };
        /**
         * Farcaster frame configuration
         */
        frame?: {
            /**
             * URL of the frame's home page
             */
            homeUrl?: string;
            /**
             * URL of the frame's icon
             */
            iconUrl?: string;
            /**
             * Name of the frame
             */
            name?: string;
            /**
             * Background color for the splash screen in hex format
             */
            splashBackgroundColor?: string;
            /**
             * URL of the splash image
             */
            splashImageUrl?: string;
            /**
             * Version of the frame
             */
            version?: string;
            /**
             * URL of the frame's webhook
             */
            webhookUrl?: string;
        };
    };
};
type GetFarcasterJsonResponse = GetFarcasterJsonResponses[keyof GetFarcasterJsonResponses];
type GetOwnedDomainsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v1/dev-tools/domains-owned";
};
type GetOwnedDomainsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - insufficient permissions
     */
    403: unknown;
    /**
     * Internal server error
     */
    500: unknown;
};
type GetOwnedDomainsError = GetOwnedDomainsErrors[keyof GetOwnedDomainsErrors];
type GetOwnedDomainsResponses = {
    /**
     * Successfully retrieved owned domains
     */
    200: {
        result: {
            /**
             * List of domains owned by the authenticated user
             */
            domains?: Array<string>;
        };
    };
};
type GetOwnedDomainsResponse = GetOwnedDomainsResponses[keyof GetOwnedDomainsResponses];
type GetApiKeysData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/v2/api-keys";
};
type GetApiKeysErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - User doesn't have permission to access API keys
     */
    403: unknown;
};
type GetApiKeysError = GetApiKeysErrors[keyof GetApiKeysErrors];
type GetApiKeysResponses = {
    /**
     * Successfully retrieved API keys
     */
    200: {
        result: {
            apiKeys: Array<ApiKey>;
        };
    };
};
type GetApiKeysResponse = GetApiKeysResponses[keyof GetApiKeysResponses];
type CreateApiKeyData = {
    body: {
        /**
         * User-provided description of the API key's purpose
         */
        description: string;
        /**
         * Timestamp when the API key should expire (in milliseconds since epoch)
         */
        expiresAt: bigint;
    };
    headers?: {
        /**
         * A unique key to ensure idempotency of the request
         */
        "idempotency-key"?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/api-keys";
};
type CreateApiKeyErrors = {
    /**
     * Bad Request - Invalid input parameters
     */
    400: unknown;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - User doesn't have permission to create API keys
     */
    403: unknown;
};
type CreateApiKeyError = CreateApiKeyErrors[keyof CreateApiKeyErrors];
type CreateApiKeyResponses = {
    /**
     * Successfully created API key
     */
    200: {
        result: {
            /**
             * Unique identifier for the created API key
             */
            id: string;
            /**
             * The secret key value that should be used for authentication (only returned once at creation)
             */
            secretKey: string;
        };
    };
};
type CreateApiKeyResponse = CreateApiKeyResponses[keyof CreateApiKeyResponses];
type RevokeApiKeyData = {
    body: {
        /**
         * ID of the API key to revoke
         */
        id: string;
    };
    headers?: {
        /**
         * A unique key to ensure idempotency of the request
         */
        "idempotency-key"?: string;
    };
    path?: never;
    query?: never;
    url: "/v2/revoke-api-key";
};
type RevokeApiKeyErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - User doesn't have permission to revoke API keys
     */
    403: unknown;
    /**
     * Not Found - API key with specified ID does not exist
     */
    404: unknown;
};
type RevokeApiKeyError = RevokeApiKeyErrors[keyof RevokeApiKeyErrors];
type RevokeApiKeyResponses = {
    /**
     * Successfully revoked the API key
     */
    200: {
        result: {
            success: boolean;
        };
    };
};
type RevokeApiKeyResponse = RevokeApiKeyResponses[keyof RevokeApiKeyResponses];
type GetConnectedAccountsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of connected accounts to return
         */
        limit?: number;
    };
    url: "/v2/connected-accounts";
};
type GetConnectedAccountsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type GetConnectedAccountsError = GetConnectedAccountsErrors[keyof GetConnectedAccountsErrors];
type GetConnectedAccountsResponses = {
    /**
     * List of connected accounts
     */
    200: {
        result: {
            accounts?: Array<{
                /**
                 * Unique identifier for the connected account
                 */
                connectedAccountId?: string;
                /**
                 * Social platform name (e.g., x, github, lens)
                 */
                platform?: "x" | "github" | "lens" | "ethereum";
                /**
                 * Username on the connected platform
                 */
                username?: string;
                /**
                 * Whether the connection has expired
                 */
                expired?: boolean;
            }>;
        };
    };
};
type GetConnectedAccountsResponse = GetConnectedAccountsResponses[keyof GetConnectedAccountsResponses];
type GetProfileCastsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Farcaster ID of the user
         */
        fid: number;
        /**
         * Maximum number of casts to return
         */
        limit?: number;
        /**
         * Cursor for pagination
         */
        cursor?: string;
    };
    url: "/v2/profile-casts";
};
type GetProfileCastsErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * User not found
     */
    404: unknown;
};
type GetProfileCastsError = GetProfileCastsErrors[keyof GetProfileCastsErrors];
type GetProfileCastsResponses = {
    /**
     * Successfully retrieved user's casts
     */
    200: {
        result: {
            casts: Array<Cast>;
        };
        next?: {
            /**
             * Cursor for fetching the next page of results
             */
            cursor?: string;
        };
    };
};
type GetProfileCastsResponse = GetProfileCastsResponses[keyof GetProfileCastsResponses];
type GetUserLikedCastsData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The user's fid (user id) whose liked casts are to be retrieved.
         */
        fid: number;
        /**
         * Number of results to limit per request.
         */
        limit?: number;
    };
    url: "/v2/user-liked-casts";
};
type GetUserLikedCastsErrors = {
    /**
     * Bad request - generic error
     */
    400: GenericBadRequestError;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Internal Server Error
     */
    500: unknown;
};
type GetUserLikedCastsError = GetUserLikedCastsErrors[keyof GetUserLikedCastsErrors];
type GetUserLikedCastsResponses = {
    /**
     * Successfully retrieved liked casts.
     */
    200: {
        result: {
            casts?: Array<Cast>;
            next?: {
                cursor?: string;
            };
        };
    };
};
type GetUserLikedCastsResponse = GetUserLikedCastsResponses[keyof GetUserLikedCastsResponses];
type GetMiniAppAnalyticsRollupData = {
    body: {
        dateRange: {
            /**
             * Start date in format 'YYYY-MM-DD' or relative like '28daysago'
             */
            startDate: string;
            /**
             * End date in format 'YYYY-MM-DD' or relative like 'today'
             */
            endDate: string;
        };
        /**
         * Analytics metrics to retrieve
         */
        measures: Array<"miniapp_opens" | "miniapp_transactions" | "miniapp_users_w_transaction" | "miniapp_users_w_open" | "miniapp_users_w_notifications_enabled" | "miniapp_users_w_notifications_disabled" | "miniapp_users_w_app_favorited" | "miniapp_users_w_app_unfavorited">;
        /**
         * Filtering restrictions for the data
         */
        restrictions: Array<{
            /**
             * Dimension to filter on
             */
            dimension: string;
            /**
             * Values to filter the dimension by
             */
            values: Array<string>;
        }>;
        /**
         * Configuration for data breakdown
         */
        breakdownSettings?: {
            /**
             * Dimensions to break down the data by
             */
            dimensions?: Array<string>;
            /**
             * Sort order for the breakdown results
             */
            order?: "asc" | "desc";
        };
    };
    path?: never;
    query?: never;
    url: "/v1/analytics/miniapps/rollup";
};
type GetMiniAppAnalyticsRollupErrors = {
    /**
     * Bad request - generic error
     */
    400: GenericBadRequestError;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - Not authorized to access this data
     */
    403: unknown;
    /**
     * Server error
     */
    500: unknown;
};
type GetMiniAppAnalyticsRollupError = GetMiniAppAnalyticsRollupErrors[keyof GetMiniAppAnalyticsRollupErrors];
type GetMiniAppAnalyticsRollupResponses = {
    /**
     * Successful analytics rollup retrieval
     */
    200: {
        result?: {
            rollup?: {
                dateRange?: {
                    startDate?: Date;
                    endDate?: Date;
                };
                restrictions?: Array<{
                    dimension?: string;
                    values?: Array<string>;
                }>;
                /**
                 * Aggregate metric totals
                 */
                totals?: Array<{
                    name?: string;
                    value?: number;
                }>;
                /**
                 * Metrics broken down by dimensions
                 */
                breakdown?: Array<{
                    slices?: Array<{
                        dimension?: string;
                        values?: Array<string>;
                    }>;
                    measures?: Array<{
                        name?: string;
                        value?: number;
                    }>;
                }>;
            };
        };
    };
};
type GetMiniAppAnalyticsRollupResponse = GetMiniAppAnalyticsRollupResponses[keyof GetMiniAppAnalyticsRollupResponses];
type InspectMiniAppUrlData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The URL of the Mini App to inspect
         */
        url: string;
    };
    url: "/v1/dev-tools/inspect-miniapp-url";
};
type InspectMiniAppUrlErrors = {
    /**
     * Bad request - generic error
     */
    400: GenericBadRequestError;
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - Not authorized to use this endpoint
     */
    403: unknown;
    /**
     * Server error
     */
    500: unknown;
};
type InspectMiniAppUrlError = InspectMiniAppUrlErrors[keyof InspectMiniAppUrlErrors];
type InspectMiniAppUrlResponses = {
    /**
     * Successful inspection of the Mini App URL
     */
    200: {
        result?: {
            facts?: {
                /**
                 * The URL that was inspected
                 */
                url?: string;
                /**
                 * HTTP status code returned by the URL
                 */
                statusCode?: number;
                /**
                 * Indicates if the Mini App embedding code is present
                 */
                miniAppEmbedPresent?: boolean;
                /**
                 * Indicates if the Mini App manifest is present
                 */
                miniAppManifestPresent?: boolean;
                /**
                 * Indicates if the Mini App embedding code is valid
                 */
                miniAppEmbedValid?: boolean;
                /**
                 * Indicates if the Mini App manifest is valid
                 */
                miniAppManifestValid?: boolean;
            };
        };
    };
};
type InspectMiniAppUrlResponse = InspectMiniAppUrlResponses[keyof InspectMiniAppUrlResponses];
type InspectImageUrlData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The URL of the image to inspect
         */
        url: string;
    };
    url: "/v1/dev-tools/inspect-image-url";
};
type InspectImageUrlErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
};
type InspectImageUrlError = InspectImageUrlErrors[keyof InspectImageUrlErrors];
type InspectImageUrlResponses = {
    /**
     * Image inspection successful
     */
    200: {
        result: {
            facts?: {
                /**
                 * The URL of the inspected image
                 */
                url?: string;
                /**
                 * HTTP status code of the response
                 */
                statusCode?: number;
                /**
                 * The cache header used by the image
                 */
                cacheHeader?: string;
                /**
                 * Cache age in seconds
                 */
                cacheAge?: number;
                /**
                 * Size of the image in bytes
                 */
                imageSizeBytes?: number;
                /**
                 * Time taken to load the image in milliseconds
                 */
                imageLoadTimeMs?: number;
            };
        };
    };
};
type InspectImageUrlResponse = InspectImageUrlResponses[keyof InspectImageUrlResponses];
type ExportMiniAppUserDataData = {
    body?: never;
    path?: never;
    query: {
        /**
         * The domain name of the mini app to export user data for
         */
        domain: string;
    };
    url: "/v1/dev-tools/export/miniapp-user-data";
};
type ExportMiniAppUserDataErrors = {
    /**
     * Authentication is required or failed
     */
    401: ErrorResponse;
    /**
     * Forbidden - insufficient permissions or not the owner of the specified domain
     */
    403: unknown;
    /**
     * Domain not found or not registered as a mini app
     */
    404: unknown;
    /**
     * Internal server error
     */
    500: unknown;
};
type ExportMiniAppUserDataError = ExportMiniAppUserDataErrors[keyof ExportMiniAppUserDataErrors];
type ExportMiniAppUserDataResponses = {
    /**
     * Successfully retrieved mini app user data
     */
    200: {
        result: {
            users?: Array<{
                /**
                 * Farcaster ID of the user
                 */
                fid: number;
                /**
                 * Token used for sending notifications to the user
                 */
                notificationToken?: string | null;
                /**
                 * Whether the user has been added/registered with the mini app
                 */
                added: boolean;
            }>;
        };
    };
};
type ExportMiniAppUserDataResponse = ExportMiniAppUserDataResponses[keyof ExportMiniAppUserDataResponses];
type ClientOptions = {
    baseUrl: "https://api.farcaster.xyz" | "https://client.farcaster.xyz" | (string & {});
};

export type { AcceptChannelInviteData, AcceptChannelInviteError, AcceptChannelInviteErrors, AcceptChannelInviteResponse, AcceptChannelInviteResponses, Action, AddDirectCastMessageReactionData, AddDirectCastMessageReactionError, AddDirectCastMessageReactionErrors, AddDirectCastMessageReactionResponse, AddDirectCastMessageReactionResponses, ApiKey, AppsByAuthorResponse, AttachEmbedsData, AttachEmbedsError, AttachEmbedsErrors, AttachEmbedsResponse, AttachEmbedsResponse2, AttachEmbedsResponses, BadRequestError, BanUserFromChannelData, BanUserFromChannelError, BanUserFromChannelErrors, BanUserFromChannelResponse, BanUserFromChannelResponses, Bio, BlockUserData, BlockUserError, BlockUserErrors, BlockUserResponse, BlockUserResponses, BookmarkedCast, BookmarkedCastsResponse, Cast, CastAction, CastCreatedResponse, CastHashResponse, CastQuote, CastQuotesResponse, CastRecastersResponse, CategorizeDirectCastConversationData, CategorizeDirectCastConversationError, CategorizeDirectCastConversationErrors, CategorizeDirectCastConversationResponse, CategorizeDirectCastConversationResponses, Channel, ChannelFollowStatus, ChannelFollowStatusResponse, ChannelFollower, ChannelFollowersResponse, ChannelFollowersYouKnowResponse, ChannelListResponse, ChannelResponse, ChannelStreaksResponse, ChannelUsersResponse, CheckUserChannelFollowStatusData, CheckUserChannelFollowStatusError, CheckUserChannelFollowStatusErrors, CheckUserChannelFollowStatusResponse, CheckUserChannelFollowStatusResponses, ClientOptions, CreateApiKeyData, CreateApiKeyError, CreateApiKeyErrors, CreateApiKeyResponse, CreateApiKeyResponses, CreateCastData, CreateCastError, CreateCastErrors, CreateCastResponse, CreateCastResponses, CreateDraftCastsData, CreateDraftCastsError, CreateDraftCastsErrors, CreateDraftCastsResponse, CreateDraftCastsResponses, CursorParam, DeleteCastData, DeleteCastError, DeleteCastErrors, DeleteCastResponse, DeleteCastResponses, DeleteDraftCastData, DeleteDraftCastError, DeleteDraftCastErrors, DeleteDraftCastResponse, DeleteDraftCastResponses, DirectCastConversation, DirectCastConversationCategorizationRequest, DirectCastConversationCategorizationResponse, DirectCastConversationMessageTtlRequest, DirectCastConversationMessageTtlResponse, DirectCastConversationMessagesResponse, DirectCastConversationNotificationsRequest, DirectCastConversationNotificationsResponse, DirectCastConversationResponse, DirectCastConversationViewerContext, DirectCastInboxResponse, DirectCastInboxResult, DirectCastManuallyMarkUnreadData, DirectCastManuallyMarkUnreadError, DirectCastManuallyMarkUnreadErrors, DirectCastManuallyMarkUnreadRequest, DirectCastManuallyMarkUnreadResponse, DirectCastManuallyMarkUnreadResponses, DirectCastMessage, DirectCastMessageMention, DirectCastMessageMetadata, DirectCastMessageReaction, DirectCastMessageReactionRequest, DirectCastMessageReactionResponse, DirectCastMessageViewerContext, DirectCastPinConversationRequest, DirectCastSendRequest, DirectCastSendResponse, DiscoverChannelsData, DiscoverChannelsError, DiscoverChannelsErrors, DiscoverChannelsResponse, DiscoverChannelsResponse2, DiscoverChannelsResponses, Draft, DraftCast, DraftCreatedResponse, DraftsResponse, ErrorResponse, ExportMiniAppUserDataData, ExportMiniAppUserDataError, ExportMiniAppUserDataErrors, ExportMiniAppUserDataResponse, ExportMiniAppUserDataResponses, FavoriteFramesResponse, FeedItemsResponse, FidParam, FollowChannelData, FollowChannelError, FollowChannelErrors, FollowChannelResponse, FollowChannelResponses, Frame, FrameApp, FrameAppsResponse, GenericBadRequestError, GenericResponse, GetAccountVerificationsData, GetAccountVerificationsError, GetAccountVerificationsErrors, GetAccountVerificationsResponse, GetAccountVerificationsResponses, GetAllChannelsData, GetAllChannelsError, GetAllChannelsErrors, GetAllChannelsResponse, GetAllChannelsResponses, GetApiKeysData, GetApiKeysError, GetApiKeysErrors, GetApiKeysResponse, GetApiKeysResponses, GetAppsByAuthorData, GetAppsByAuthorError, GetAppsByAuthorErrors, GetAppsByAuthorResponse, GetAppsByAuthorResponses, GetAvailableInvitesData, GetAvailableInvitesError, GetAvailableInvitesErrors, GetAvailableInvitesResponse, GetAvailableInvitesResponses, GetBlockedUsersData, GetBlockedUsersError, GetBlockedUsersErrors, GetBlockedUsersResponse, GetBlockedUsersResponses, GetBookmarkedCastsData, GetBookmarkedCastsError, GetBookmarkedCastsErrors, GetBookmarkedCastsResponse, GetBookmarkedCastsResponses, GetCastLikesData, GetCastLikesError, GetCastLikesErrors, GetCastLikesResponse, GetCastLikesResponses, GetCastQuotesData, GetCastQuotesError, GetCastQuotesErrors, GetCastQuotesResponse, GetCastQuotesResponses, GetCastRecastersData, GetCastRecastersError, GetCastRecastersErrors, GetCastRecastersResponse, GetCastRecastersResponses, GetCastsByFidData, GetCastsByFidError, GetCastsByFidErrors, GetCastsByFidResponse, GetCastsByFidResponses, GetChannelBannedUsersData, GetChannelBannedUsersError, GetChannelBannedUsersErrors, GetChannelBannedUsersResponse, GetChannelBannedUsersResponses, GetChannelData, GetChannelDetailsData, GetChannelDetailsError, GetChannelDetailsErrors, GetChannelDetailsResponse, GetChannelDetailsResponses, GetChannelError, GetChannelErrors, GetChannelFollowersData, GetChannelFollowersError, GetChannelFollowersErrors, GetChannelFollowersResponse, GetChannelFollowersResponses, GetChannelFollowersYouKnowData, GetChannelFollowersYouKnowError, GetChannelFollowersYouKnowErrors, GetChannelFollowersYouKnowResponse, GetChannelFollowersYouKnowResponses, GetChannelInvitesData, GetChannelInvitesError, GetChannelInvitesErrors, GetChannelInvitesResponse, GetChannelInvitesResponses, GetChannelMembersData, GetChannelMembersError, GetChannelMembersErrors, GetChannelMembersResponse, GetChannelMembersResponses, GetChannelModeratedCastsData, GetChannelModeratedCastsError, GetChannelModeratedCastsErrors, GetChannelModeratedCastsResponse, GetChannelModeratedCastsResponses, GetChannelResponse, GetChannelResponses, GetChannelRestrictedUsersData, GetChannelRestrictedUsersError, GetChannelRestrictedUsersErrors, GetChannelRestrictedUsersResponse, GetChannelRestrictedUsersResponses, GetChannelStreaksForUserData, GetChannelStreaksForUserError, GetChannelStreaksForUserErrors, GetChannelStreaksForUserResponse, GetChannelStreaksForUserResponses, GetChannelUsersData, GetChannelUsersError, GetChannelUsersErrors, GetChannelUsersResponse, GetChannelUsersResponses, GetConnectedAccountsData, GetConnectedAccountsError, GetConnectedAccountsErrors, GetConnectedAccountsResponse, GetConnectedAccountsResponses, GetCreatorRewardWinnersData, GetCreatorRewardWinnersError, GetCreatorRewardWinnersErrors, GetCreatorRewardWinnersResponse, GetCreatorRewardWinnersResponses, GetCurrentUserData, GetCurrentUserError, GetCurrentUserErrors, GetCurrentUserResponse, GetCurrentUserResponses, GetDeveloperRewardWinnersData, GetDeveloperRewardWinnersError, GetDeveloperRewardWinnersErrors, GetDeveloperRewardWinnersResponse, GetDeveloperRewardWinnersResponses, GetDirectCastConversationData, GetDirectCastConversationError, GetDirectCastConversationErrors, GetDirectCastConversationMessagesData, GetDirectCastConversationMessagesError, GetDirectCastConversationMessagesErrors, GetDirectCastConversationMessagesResponse, GetDirectCastConversationMessagesResponses, GetDirectCastConversationRecentMessagesData, GetDirectCastConversationRecentMessagesError, GetDirectCastConversationRecentMessagesErrors, GetDirectCastConversationRecentMessagesResponse, GetDirectCastConversationRecentMessagesResponses, GetDirectCastConversationResponse, GetDirectCastConversationResponses, GetDirectCastInboxData, GetDirectCastInboxError, GetDirectCastInboxErrors, GetDirectCastInboxResponse, GetDirectCastInboxResponses, GetDiscoverableActionsData, GetDiscoverableActionsError, GetDiscoverableActionsErrors, GetDiscoverableActionsResponse, GetDiscoverableActionsResponses, GetDiscoverableComposerActionsData, GetDiscoverableComposerActionsError, GetDiscoverableComposerActionsErrors, GetDiscoverableComposerActionsResponse, GetDiscoverableComposerActionsResponses, GetDomainManifestData, GetDomainManifestError, GetDomainManifestErrors, GetDomainManifestResponse, GetDomainManifestResponses, GetDraftCastsData, GetDraftCastsError, GetDraftCastsErrors, GetDraftCastsResponse, GetDraftCastsResponses, GetFarcasterJsonData, GetFarcasterJsonError, GetFarcasterJsonErrors, GetFarcasterJsonResponse, GetFarcasterJsonResponses, GetFeedItemsData, GetFeedItemsError, GetFeedItemsErrors, GetFeedItemsResponse, GetFeedItemsResponses, GetFollowersData, GetFollowersError, GetFollowersErrors, GetFollowersResponse, GetFollowersResponses, GetFollowingData, GetFollowingError, GetFollowingErrors, GetFollowingResponse, GetFollowingResponses, GetHighlightedChannelsData, GetHighlightedChannelsError, GetHighlightedChannelsErrors, GetHighlightedChannelsResponse, GetHighlightedChannelsResponses, GetMetaTagsData, GetMetaTagsError, GetMetaTagsErrors, GetMetaTagsResponse, GetMetaTagsResponses, GetMiniAppAnalyticsRollupData, GetMiniAppAnalyticsRollupError, GetMiniAppAnalyticsRollupErrors, GetMiniAppAnalyticsRollupResponse, GetMiniAppAnalyticsRollupResponses, GetMutedKeywordsData, GetMutedKeywordsError, GetMutedKeywordsErrors, GetMutedKeywordsResponse, GetMutedKeywordsResponses, GetMutualFollowersData, GetMutualFollowersError, GetMutualFollowersErrors, GetMutualFollowersResponse, GetMutualFollowersResponses, GetNotificationsData, GetNotificationsError, GetNotificationsErrors, GetNotificationsResponse, GetNotificationsResponses, GetOwnedDomainsData, GetOwnedDomainsError, GetOwnedDomainsErrors, GetOwnedDomainsResponse, GetOwnedDomainsResponses, GetProfileCastsData, GetProfileCastsError, GetProfileCastsErrors, GetProfileCastsResponse, GetProfileCastsResponses, GetRewardsLeaderboardData, GetRewardsLeaderboardError, GetRewardsLeaderboardErrors, GetRewardsLeaderboardResponse, GetRewardsLeaderboardResponses, GetRewardsMetadataData, GetRewardsMetadataError, GetRewardsMetadataErrors, GetRewardsMetadataResponse, GetRewardsMetadataResponses, GetSponsoredInvitesData, GetSponsoredInvitesError, GetSponsoredInvitesErrors, GetSponsoredInvitesResponse, GetSponsoredInvitesResponses, GetStarterPackData, GetStarterPackError, GetStarterPackErrors, GetStarterPackMembersData, GetStarterPackMembersError, GetStarterPackMembersErrors, GetStarterPackMembersResponse, GetStarterPackMembersResponses, GetStarterPackResponse, GetStarterPackResponses, GetStarterPackUsersData, GetStarterPackUsersError, GetStarterPackUsersErrors, GetStarterPackUsersResponse, GetStarterPackUsersResponses, GetSuggestedStarterPacksData, GetSuggestedStarterPacksError, GetSuggestedStarterPacksErrors, GetSuggestedStarterPacksResponse, GetSuggestedStarterPacksResponses, GetSuggestedUsersData, GetSuggestedUsersError, GetSuggestedUsersErrors, GetSuggestedUsersResponse, GetSuggestedUsersResponses, GetTopFrameAppsData, GetTopFrameAppsError, GetTopFrameAppsErrors, GetTopFrameAppsResponse, GetTopFrameAppsResponses, GetTopMiniAppsData, GetTopMiniAppsError, GetTopMiniAppsErrors, GetTopMiniAppsResponse, GetTopMiniAppsResponses, GetUnseenCountsData, GetUnseenCountsError, GetUnseenCountsErrors, GetUnseenCountsResponse, GetUnseenCountsResponses, GetUserAppContextData, GetUserAppContextError, GetUserAppContextErrors, GetUserAppContextResponse, GetUserAppContextResponses, GetUserByFidData, GetUserByFidError, GetUserByFidErrors, GetUserByFidResponse, GetUserByFidResponses, GetUserByUsernameData, GetUserByUsernameError, GetUserByUsernameErrors, GetUserByUsernameResponse, GetUserByUsernameResponses, GetUserByVerificationAddressData, GetUserByVerificationAddressError, GetUserByVerificationAddressErrors, GetUserByVerificationAddressResponse, GetUserByVerificationAddressResponses, GetUserData, GetUserError, GetUserErrors, GetUserFavoriteFramesData, GetUserFavoriteFramesError, GetUserFavoriteFramesErrors, GetUserFavoriteFramesResponse, GetUserFavoriteFramesResponses, GetUserFollowedChannelsData, GetUserFollowedChannelsError, GetUserFollowedChannelsErrors, GetUserFollowedChannelsResponse, GetUserFollowedChannelsResponses, GetUserFollowingChannelsData, GetUserFollowingChannelsError, GetUserFollowingChannelsErrors, GetUserFollowingChannelsResponse, GetUserFollowingChannelsResponses, GetUserLikedCastsData, GetUserLikedCastsError, GetUserLikedCastsErrors, GetUserLikedCastsResponse, GetUserLikedCastsResponses, GetUserOnboardingStateData, GetUserOnboardingStateError, GetUserOnboardingStateErrors, GetUserOnboardingStateResponse, GetUserOnboardingStateResponses, GetUserPreferencesData, GetUserPreferencesError, GetUserPreferencesErrors, GetUserPreferencesResponse, GetUserPreferencesResponses, GetUserPrimaryAddressData, GetUserPrimaryAddressError, GetUserPrimaryAddressErrors, GetUserPrimaryAddressResponse, GetUserPrimaryAddressResponses, GetUserPrimaryAddressesData, GetUserPrimaryAddressesError, GetUserPrimaryAddressesErrors, GetUserPrimaryAddressesResponse, GetUserPrimaryAddressesResponses, GetUserResponse, GetUserResponses, GetUserRewardsScoresData, GetUserRewardsScoresError, GetUserRewardsScoresErrors, GetUserRewardsScoresResponse, GetUserRewardsScoresResponses, GetUserStarterPacksData, GetUserStarterPacksError, GetUserStarterPacksErrors, GetUserStarterPacksResponse, GetUserStarterPacksResponses, GetUserThreadCastsData, GetUserThreadCastsError, GetUserThreadCastsErrors, GetUserThreadCastsResponse, GetUserThreadCastsResponses, GetVerificationsData, GetVerificationsError, GetVerificationsErrors, GetVerificationsResponse, GetVerificationsResponses, HighlightedChannelsResponse, ImageEmbed, InspectImageUrlData, InspectImageUrlError, InspectImageUrlErrors, InspectImageUrlResponse, InspectImageUrlResponses, InspectMiniAppUrlData, InspectMiniAppUrlError, InspectMiniAppUrlErrors, InspectMiniAppUrlResponse, InspectMiniAppUrlResponses, InviteUserToChannelData, InviteUserToChannelError, InviteUserToChannelErrors, InviteUserToChannelResponse, InviteUserToChannelResponses, InvitesAvailableResponse, LikeCastData, LikeCastError, LikeCastErrors, LikeCastResponse, LikeCastResponses, LimitParam, Location, MarkAllNotificationsReadData, MarkAllNotificationsReadError, MarkAllNotificationsReadErrors, MarkAllNotificationsReadResponse, MarkAllNotificationsReadResponses, MiniApp, MiniAppViewerContext, ModerateCastData, ModerateCastError, ModerateCastErrors, ModerateCastResponse, ModerateCastResponses, MuteKeywordData, MuteKeywordError, MuteKeywordErrors, MuteKeywordResponse, MuteKeywordResponses, MutedKeyword, MutedKeywordProperties, MutedKeywordsResponse, NotificationsResponse, OnboardingState, OnboardingStateResponse, PaginatedResponse, PaginationCursor, PinCastToChannelData, PinCastToChannelError, PinCastToChannelErrors, PinCastToChannelResponse, PinCastToChannelResponses, PinDirectCastConversationData, PinDirectCastConversationError, PinDirectCastConversationErrors, PinDirectCastConversationResponse, PinDirectCastConversationResponses, Profile, ProfilePicture, RankedMiniApp, RawChannel, RawChannelResponse, RecastCastData, RecastCastError, RecastCastErrors, RecastCastResponse, RecastCastResponses, Recaster, RemoveChannelInviteData, RemoveChannelInviteError, RemoveChannelInviteErrors, RemoveChannelInviteResponse, RemoveChannelInviteResponses, RemoveDirectCastMessageReactionData, RemoveDirectCastMessageReactionError, RemoveDirectCastMessageReactionErrors, RemoveDirectCastMessageReactionResponse, RemoveDirectCastMessageReactionResponses, RevokeApiKeyData, RevokeApiKeyError, RevokeApiKeyErrors, RevokeApiKeyResponse, RevokeApiKeyResponses, RewardsLeaderboardResponse, RewardsMetadataResponse, RewardsScoresResponse, SearchChannelsData, SearchChannelsError, SearchChannelsErrors, SearchChannelsResponse, SearchChannelsResponse2, SearchChannelsResponses, SendDirectCastData, SendDirectCastError, SendDirectCastErrors, SendDirectCastMessageData, SendDirectCastMessageError, SendDirectCastMessageErrors, SendDirectCastMessageResponse, SendDirectCastMessageResponses, SendDirectCastResponse, SendDirectCastResponses, SetDirectCastConversationMessageTtlData, SetDirectCastConversationMessageTtlError, SetDirectCastConversationMessageTtlErrors, SetDirectCastConversationMessageTtlResponse, SetDirectCastConversationMessageTtlResponses, SetLastCheckedTimestampData, SetLastCheckedTimestampError, SetLastCheckedTimestampErrors, SetLastCheckedTimestampResponse, SetLastCheckedTimestampResponses, SponsoredInvitesResponse, StarterPack, StarterPackResponse, StarterPackUpdateRequest, StarterPackUsersResponse, StarterPacksResponse, SuccessResponse, SuggestedUsersResponse, TopMiniAppsResponse, UnbanUserFromChannelData, UnbanUserFromChannelError, UnbanUserFromChannelErrors, UnbanUserFromChannelResponse, UnbanUserFromChannelResponses, UnblockUserData, UnblockUserError, UnblockUserErrors, UnblockUserResponse, UnblockUserResponses, UndoRecastData, UndoRecastError, UndoRecastErrors, UndoRecastResponse, UndoRecastResponses, UnfollowChannelData, UnfollowChannelError, UnfollowChannelErrors, UnfollowChannelResponse, UnfollowChannelResponses, UnlikeCastData, UnlikeCastError, UnlikeCastErrors, UnlikeCastResponse, UnlikeCastResponses, UnmuteKeywordData, UnmuteKeywordError, UnmuteKeywordErrors, UnmuteKeywordResponse, UnmuteKeywordResponses, UnpinCastFromChannelData, UnpinCastFromChannelError, UnpinCastFromChannelErrors, UnpinCastFromChannelResponse, UnpinCastFromChannelResponses, UnpinDirectCastConversationData, UnpinDirectCastConversationError, UnpinDirectCastConversationErrors, UnpinDirectCastConversationResponse, UnpinDirectCastConversationResponses, UnseenCountsResponse, UpdateDirectCastConversationNotificationsData, UpdateDirectCastConversationNotificationsError, UpdateDirectCastConversationNotificationsErrors, UpdateDirectCastConversationNotificationsResponse, UpdateDirectCastConversationNotificationsResponses, UpdateStarterPackData, UpdateStarterPackError, UpdateStarterPackErrors, UpdateStarterPackResponse, UpdateStarterPackResponses, UrlEmbed, User, UserAppContextResponse, UserByFidResponse, UserExtras, UserPreferencesResponse, UserResponse, UserResponseUserResponse, UserThreadCastsResponse, UserWithExtras, UsersResponse, UsersWithCountResponse, ValidationError, VerifiedAddress, VideoEmbed, ViewerContext, Winner };