@nekofar/warpcast/dist/chunk-PG5LJZZW.mjs

TypeScript client for interacting with Warpcast APIs

import {
  client
} from "./chunk-3KA6NFYD.mjs";
import {
  createCastResponseTransformer,
  getApiKeysResponseTransformer,
  getCastsByFidResponseTransformer,
  getCreatorRewardWinnersResponseTransformer,
  getDirectCastConversationMessagesResponseTransformer,
  getDirectCastConversationRecentMessagesResponseTransformer,
  getDirectCastConversationResponseTransformer,
  getDirectCastInboxResponseTransformer,
  getFeedItemsResponseTransformer,
  getMiniAppAnalyticsRollupResponseTransformer,
  getProfileCastsResponseTransformer,
  getStarterPackMembersResponseTransformer,
  getUserLikedCastsResponseTransformer
} from "./chunk-BDNCTXN6.mjs";
import {
  zAcceptChannelInviteData,
  zAcceptChannelInviteResponse,
  zAddDirectCastMessageReactionData,
  zAddDirectCastMessageReactionResponse,
  zAttachEmbedsData,
  zAttachEmbedsResponse2,
  zBanUserFromChannelData,
  zBanUserFromChannelResponse,
  zBlockUserData,
  zBlockUserResponse,
  zCategorizeDirectCastConversationData,
  zCategorizeDirectCastConversationResponse,
  zCheckUserChannelFollowStatusData,
  zCheckUserChannelFollowStatusResponse,
  zCreateApiKeyData,
  zCreateApiKeyResponse,
  zCreateCastData,
  zCreateCastResponse,
  zCreateDraftCastsData,
  zCreateDraftCastsResponse,
  zDeleteCastData,
  zDeleteCastResponse,
  zDeleteDraftCastData,
  zDeleteDraftCastResponse,
  zDirectCastManuallyMarkUnreadData,
  zDirectCastManuallyMarkUnreadResponse,
  zDiscoverChannelsData,
  zDiscoverChannelsResponse2,
  zExportMiniAppUserDataData,
  zExportMiniAppUserDataResponse,
  zFollowChannelData,
  zFollowChannelResponse,
  zGetAccountVerificationsData,
  zGetAccountVerificationsResponse,
  zGetAllChannelsData,
  zGetAllChannelsResponse,
  zGetApiKeysData,
  zGetApiKeysResponse,
  zGetAppsByAuthorData,
  zGetAppsByAuthorResponse,
  zGetAvailableInvitesData,
  zGetAvailableInvitesResponse,
  zGetBlockedUsersData,
  zGetBlockedUsersResponse,
  zGetBookmarkedCastsData,
  zGetBookmarkedCastsResponse,
  zGetCastLikesData,
  zGetCastLikesResponse,
  zGetCastQuotesData,
  zGetCastQuotesResponse,
  zGetCastRecastersData,
  zGetCastRecastersResponse,
  zGetCastsByFidData,
  zGetCastsByFidResponse,
  zGetChannelBannedUsersData,
  zGetChannelBannedUsersResponse,
  zGetChannelData,
  zGetChannelDetailsData,
  zGetChannelDetailsResponse,
  zGetChannelFollowersData,
  zGetChannelFollowersResponse,
  zGetChannelFollowersYouKnowData,
  zGetChannelFollowersYouKnowResponse,
  zGetChannelInvitesData,
  zGetChannelInvitesResponse,
  zGetChannelMembersData,
  zGetChannelMembersResponse,
  zGetChannelModeratedCastsData,
  zGetChannelModeratedCastsResponse,
  zGetChannelResponse,
  zGetChannelRestrictedUsersData,
  zGetChannelRestrictedUsersResponse,
  zGetChannelStreaksForUserData,
  zGetChannelStreaksForUserResponse,
  zGetChannelUsersData,
  zGetChannelUsersResponse,
  zGetConnectedAccountsData,
  zGetConnectedAccountsResponse,
  zGetCreatorRewardWinnersData,
  zGetCreatorRewardWinnersResponse,
  zGetCurrentUserData,
  zGetCurrentUserResponse,
  zGetDeveloperRewardWinnersData,
  zGetDeveloperRewardWinnersResponse,
  zGetDirectCastConversationData,
  zGetDirectCastConversationMessagesData,
  zGetDirectCastConversationMessagesResponse,
  zGetDirectCastConversationRecentMessagesData,
  zGetDirectCastConversationRecentMessagesResponse,
  zGetDirectCastConversationResponse,
  zGetDirectCastInboxData,
  zGetDirectCastInboxResponse,
  zGetDiscoverableActionsData,
  zGetDiscoverableActionsResponse,
  zGetDiscoverableComposerActionsData,
  zGetDiscoverableComposerActionsResponse,
  zGetDomainManifestData,
  zGetDomainManifestResponse,
  zGetDraftCastsData,
  zGetDraftCastsResponse,
  zGetFarcasterJsonData,
  zGetFarcasterJsonResponse,
  zGetFeedItemsData,
  zGetFeedItemsResponse,
  zGetFollowersData,
  zGetFollowersResponse,
  zGetFollowingData,
  zGetFollowingResponse,
  zGetHighlightedChannelsData,
  zGetHighlightedChannelsResponse,
  zGetMetaTagsData,
  zGetMetaTagsResponse,
  zGetMiniAppAnalyticsRollupData,
  zGetMiniAppAnalyticsRollupResponse,
  zGetMutedKeywordsData,
  zGetMutedKeywordsResponse,
  zGetMutualFollowersData,
  zGetMutualFollowersResponse,
  zGetNotificationsData,
  zGetNotificationsResponse,
  zGetOwnedDomainsData,
  zGetOwnedDomainsResponse,
  zGetProfileCastsData,
  zGetProfileCastsResponse,
  zGetRewardsLeaderboardData,
  zGetRewardsLeaderboardResponse,
  zGetRewardsMetadataData,
  zGetRewardsMetadataResponse,
  zGetSponsoredInvitesData,
  zGetSponsoredInvitesResponse,
  zGetStarterPackData,
  zGetStarterPackMembersData,
  zGetStarterPackMembersResponse,
  zGetStarterPackResponse,
  zGetStarterPackUsersData,
  zGetStarterPackUsersResponse,
  zGetSuggestedStarterPacksData,
  zGetSuggestedStarterPacksResponse,
  zGetSuggestedUsersData,
  zGetSuggestedUsersResponse,
  zGetTopFrameAppsData,
  zGetTopFrameAppsResponse,
  zGetTopMiniAppsData,
  zGetTopMiniAppsResponse,
  zGetUnseenCountsData,
  zGetUnseenCountsResponse,
  zGetUserAppContextData,
  zGetUserAppContextResponse,
  zGetUserByFidData,
  zGetUserByFidResponse,
  zGetUserByUsernameData,
  zGetUserByUsernameResponse,
  zGetUserByVerificationAddressData,
  zGetUserByVerificationAddressResponse,
  zGetUserData,
  zGetUserFavoriteFramesData,
  zGetUserFavoriteFramesResponse,
  zGetUserFollowedChannelsData,
  zGetUserFollowedChannelsResponse,
  zGetUserFollowingChannelsData,
  zGetUserFollowingChannelsResponse,
  zGetUserLikedCastsData,
  zGetUserLikedCastsResponse,
  zGetUserOnboardingStateData,
  zGetUserOnboardingStateResponse,
  zGetUserPreferencesData,
  zGetUserPreferencesResponse,
  zGetUserPrimaryAddressData,
  zGetUserPrimaryAddressResponse,
  zGetUserPrimaryAddressesData,
  zGetUserPrimaryAddressesResponse,
  zGetUserResponse,
  zGetUserRewardsScoresData,
  zGetUserRewardsScoresResponse,
  zGetUserStarterPacksData,
  zGetUserStarterPacksResponse,
  zGetUserThreadCastsData,
  zGetUserThreadCastsResponse,
  zGetVerificationsData,
  zGetVerificationsResponse,
  zInspectImageUrlData,
  zInspectImageUrlResponse,
  zInspectMiniAppUrlData,
  zInspectMiniAppUrlResponse,
  zInviteUserToChannelData,
  zInviteUserToChannelResponse,
  zLikeCastData,
  zLikeCastResponse,
  zMarkAllNotificationsReadData,
  zMarkAllNotificationsReadResponse,
  zModerateCastData,
  zModerateCastResponse,
  zMuteKeywordData,
  zMuteKeywordResponse,
  zPinCastToChannelData,
  zPinCastToChannelResponse,
  zPinDirectCastConversationData,
  zPinDirectCastConversationResponse,
  zRecastCastData,
  zRecastCastResponse,
  zRemoveChannelInviteData,
  zRemoveChannelInviteResponse,
  zRemoveDirectCastMessageReactionData,
  zRemoveDirectCastMessageReactionResponse,
  zRevokeApiKeyData,
  zRevokeApiKeyResponse,
  zSearchChannelsData,
  zSearchChannelsResponse2,
  zSendDirectCastData,
  zSendDirectCastMessageData,
  zSendDirectCastMessageResponse,
  zSendDirectCastResponse,
  zSetDirectCastConversationMessageTtlData,
  zSetDirectCastConversationMessageTtlResponse,
  zSetLastCheckedTimestampData,
  zSetLastCheckedTimestampResponse,
  zUnbanUserFromChannelData,
  zUnbanUserFromChannelResponse,
  zUnblockUserData,
  zUnblockUserResponse,
  zUndoRecastData,
  zUndoRecastResponse,
  zUnfollowChannelData,
  zUnfollowChannelResponse,
  zUnlikeCastData,
  zUnlikeCastResponse,
  zUnmuteKeywordData,
  zUnmuteKeywordResponse,
  zUnpinCastFromChannelData,
  zUnpinCastFromChannelResponse,
  zUnpinDirectCastConversationData,
  zUnpinDirectCastConversationResponse,
  zUpdateDirectCastConversationNotificationsData,
  zUpdateDirectCastConversationNotificationsResponse,
  zUpdateStarterPackData,
  zUpdateStarterPackResponse
} from "./chunk-G2QHMCCK.mjs";

// src/client/sdk.gen.ts
var getUserOnboardingState = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserOnboardingStateData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserOnboardingStateResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/onboarding-state",
    ...options
  });
};
var getUserByFid = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserByFidData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserByFidResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user-by-fid",
    ...options
  });
};
var getDirectCastInbox = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetDirectCastInboxData.parseAsync(data);
    },
    responseTransformer: getDirectCastInboxResponseTransformer,
    responseValidator: async (data) => {
      return await zGetDirectCastInboxResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-inbox",
    ...options
  });
};
var getUserAppContext = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserAppContextData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserAppContextResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user-app-context",
    ...options
  });
};
var getUserPreferences = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserPreferencesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserPreferencesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user-preferences",
    ...options
  });
};
var getHighlightedChannels = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetHighlightedChannelsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetHighlightedChannelsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/highlighted-channels",
    ...options
  });
};
var getFeedItems = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zGetFeedItemsData.parseAsync(data);
    },
    responseTransformer: getFeedItemsResponseTransformer,
    responseValidator: async (data) => {
      return await zGetFeedItemsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/feed-items",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getUser = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user",
    ...options
  });
};
var getUserFollowingChannels = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserFollowingChannelsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserFollowingChannelsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user-following-channels",
    ...options
  });
};
var getSuggestedUsers = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetSuggestedUsersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetSuggestedUsersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/suggested-users",
    ...options
  });
};
var getUserFavoriteFrames = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserFavoriteFramesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserFavoriteFramesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/favorite-frames",
    ...options
  });
};
var getUserByUsername = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserByUsernameData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserByUsernameResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user-by-username",
    ...options
  });
};
var getChannelStreaksForUser = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelStreaksForUserData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelStreaksForUserResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/channel-streaks",
    ...options
  });
};
var getUnseenCounts = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUnseenCountsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUnseenCountsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/unseen",
    ...options
  });
};
var getUserThreadCasts = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserThreadCastsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserThreadCastsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/user-thread-casts",
    ...options
  });
};
var getChannelFollowersYouKnow = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelFollowersYouKnowData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelFollowersYouKnowResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/channel-followers-you-know",
    ...options
  });
};
var markAllNotificationsRead = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zMarkAllNotificationsReadData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zMarkAllNotificationsReadResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/mark-all-notifications-read",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getNotifications = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetNotificationsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetNotificationsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/notifications-for-tab",
    ...options
  });
};
var setLastCheckedTimestamp = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zSetLastCheckedTimestampData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zSetLastCheckedTimestampResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/set-last-checked-timestamp",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getDirectCastConversation = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetDirectCastConversationData.parseAsync(data);
    },
    responseTransformer: getDirectCastConversationResponseTransformer,
    responseValidator: async (data) => {
      return await zGetDirectCastConversationResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-conversation",
    ...options
  });
};
var categorizeDirectCastConversation = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zCategorizeDirectCastConversationData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zCategorizeDirectCastConversationResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-conversation-categorization",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getDirectCastConversationMessages = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetDirectCastConversationMessagesData.parseAsync(data);
    },
    responseTransformer: getDirectCastConversationMessagesResponseTransformer,
    responseValidator: async (data) => {
      return await zGetDirectCastConversationMessagesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-conversation-messages",
    ...options
  });
};
var setDirectCastConversationMessageTtl = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zSetDirectCastConversationMessageTtlData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zSetDirectCastConversationMessageTtlResponse.parseAsync(
        data
      );
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-conversation-message-ttl",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var updateDirectCastConversationNotifications = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zUpdateDirectCastConversationNotificationsData.parseAsync(
        data
      );
    },
    responseValidator: async (data) => {
      return await zUpdateDirectCastConversationNotificationsResponse.parseAsync(
        data
      );
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-conversation-notifications",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getDirectCastConversationRecentMessages = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetDirectCastConversationRecentMessagesData.parseAsync(
        data
      );
    },
    responseTransformer: getDirectCastConversationRecentMessagesResponseTransformer,
    responseValidator: async (data) => {
      return await zGetDirectCastConversationRecentMessagesResponse.parseAsync(
        data
      );
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-conversation-recent-messages",
    ...options
  });
};
var sendDirectCastMessage = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zSendDirectCastMessageData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zSendDirectCastMessageResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-send",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var directCastManuallyMarkUnread = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zDirectCastManuallyMarkUnreadData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zDirectCastManuallyMarkUnreadResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-manually-mark-unread",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var removeDirectCastMessageReaction = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zRemoveDirectCastMessageReactionData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zRemoveDirectCastMessageReactionResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-message-reaction",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var addDirectCastMessageReaction = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zAddDirectCastMessageReactionData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zAddDirectCastMessageReactionResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-message-reaction",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var unpinDirectCastConversation = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zUnpinDirectCastConversationData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUnpinDirectCastConversationResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-pin-conversation",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var pinDirectCastConversation = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zPinDirectCastConversationData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zPinDirectCastConversationResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/direct-cast-pin-conversation",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var discoverChannels = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zDiscoverChannelsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zDiscoverChannelsResponse2.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/discover-channels",
    ...options
  });
};
var getAvailableInvites = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetAvailableInvitesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetAvailableInvitesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/invites-available",
    ...options
  });
};
var getSponsoredInvites = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetSponsoredInvitesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetSponsoredInvitesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/warpcast-sponsored-invites",
    ...options
  });
};
var getRewardsLeaderboard = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetRewardsLeaderboardData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetRewardsLeaderboardResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/rewards-leaderboard",
    ...options
  });
};
var getUserRewardsScores = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserRewardsScoresData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserRewardsScoresResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/rewards-scores-for-user",
    ...options
  });
};
var getRewardsMetadata = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetRewardsMetadataData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetRewardsMetadataResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/rewards-metadata",
    ...options
  });
};
var getBookmarkedCasts = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetBookmarkedCastsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetBookmarkedCastsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/bookmarked-casts",
    ...options
  });
};
var getUserStarterPacks = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserStarterPacksData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserStarterPacksResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/starter-packs",
    ...options
  });
};
var getSuggestedStarterPacks = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetSuggestedStarterPacksData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetSuggestedStarterPacksResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/starter-packs/suggested",
    ...options
  });
};
var getStarterPack = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetStarterPackData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetStarterPackResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/starter-pack",
    ...options
  });
};
var updateStarterPack = (options) => {
  return (options.client ?? client).patch({
    requestValidator: async (data) => {
      return await zUpdateStarterPackData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUpdateStarterPackResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/starter-pack",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getStarterPackUsers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetStarterPackUsersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetStarterPackUsersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/starter-pack-users",
    ...options
  });
};
var getChannel = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/channel",
    ...options
  });
};
var getChannelUsers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelUsersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelUsersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/channel-users",
    ...options
  });
};
var getFollowing = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetFollowingData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetFollowingResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/following",
    ...options
  });
};
var getFollowers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetFollowersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetFollowersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/followers",
    ...options
  });
};
var getMutualFollowers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetMutualFollowersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetMutualFollowersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/followers-you-know",
    ...options
  });
};
var getTopFrameApps = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetTopFrameAppsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetTopFrameAppsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/top-frameapps",
    ...options
  });
};
var getTopMiniApps = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetTopMiniAppsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetTopMiniAppsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/top-mini-apps",
    ...options
  });
};
var getVerifications = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetVerificationsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetVerificationsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/verifications",
    ...options
  });
};
var getMutedKeywords = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetMutedKeywordsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetMutedKeywordsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/get-muted-keywords",
    ...options
  });
};
var muteKeyword = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zMuteKeywordData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zMuteKeywordResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/mute-keyword",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var unmuteKeyword = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zUnmuteKeywordData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUnmuteKeywordResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/unmute-keyword",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var unlikeCast = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zUnlikeCastData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUnlikeCastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/cast-likes",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getCastLikes = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetCastLikesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetCastLikesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/cast-likes",
    ...options
  });
};
var likeCast = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zLikeCastData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zLikeCastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/cast-likes",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var undoRecast = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zUndoRecastData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUndoRecastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/recasts",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var recastCast = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zRecastCastData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zRecastCastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/recasts",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var attachEmbeds = (options) => {
  return (options.client ?? client).put({
    requestValidator: async (data) => {
      return await zAttachEmbedsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zAttachEmbedsResponse2.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/cast-attachments",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getCastRecasters = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetCastRecastersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetCastRecastersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/cast-recasters",
    ...options
  });
};
var getCastQuotes = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetCastQuotesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetCastQuotesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/cast-quotes",
    ...options
  });
};
var getCurrentUser = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetCurrentUserData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetCurrentUserResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/me",
    ...options
  });
};
var searchChannels = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zSearchChannelsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zSearchChannelsResponse2.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/search-channels",
    ...options
  });
};
var getDraftCasts = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetDraftCastsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetDraftCastsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/draft-caststorms",
    ...options
  });
};
var createDraftCasts = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zCreateDraftCastsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zCreateDraftCastsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/draft-caststorms",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var deleteDraftCast = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zDeleteDraftCastData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zDeleteDraftCastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/draft-casts",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var deleteCast = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zDeleteCastData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zDeleteCastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/casts",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getCastsByFid = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetCastsByFidData.parseAsync(data);
    },
    responseTransformer: getCastsByFidResponseTransformer,
    responseValidator: async (data) => {
      return await zGetCastsByFidResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/casts",
    ...options
  });
};
var createCast = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zCreateCastData.parseAsync(data);
    },
    responseTransformer: createCastResponseTransformer,
    responseValidator: async (data) => {
      return await zCreateCastResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/casts",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getAllChannels = (options) => {
  return (options?.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetAllChannelsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetAllChannelsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v2/all-channels",
    ...options
  });
};
var getChannelDetails = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelDetailsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelDetailsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/channel",
    ...options
  });
};
var getChannelFollowers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelFollowersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelFollowersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/channel-followers",
    ...options
  });
};
var getUserFollowedChannels = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetUserFollowedChannelsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetUserFollowedChannelsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/user-following-channels",
    ...options
  });
};
var checkUserChannelFollowStatus = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zCheckUserChannelFollowStatusData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zCheckUserChannelFollowStatusResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/v1/user-channel",
    ...options
  });
};
var getChannelMembers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelMembersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelMembersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-members",
    ...options
  });
};
var removeChannelInvite = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zRemoveChannelInviteData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zRemoveChannelInviteResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-invites",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getChannelInvites = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelInvitesData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelInvitesResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-invites",
    ...options
  });
};
var acceptChannelInvite = (options) => {
  return (options.client ?? client).patch({
    requestValidator: async (data) => {
      return await zAcceptChannelInviteData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zAcceptChannelInviteResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-invites",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var inviteUserToChannel = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zInviteUserToChannelData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zInviteUserToChannelResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-invites",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getChannelModeratedCasts = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelModeratedCastsData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelModeratedCastsResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/moderated-casts",
    ...options
  });
};
var getChannelRestrictedUsers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelRestrictedUsersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelRestrictedUsersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-restricted-users",
    ...options
  });
};
var unbanUserFromChannel = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zUnbanUserFromChannelData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUnbanUserFromChannelResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-bans",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getChannelBannedUsers = (options) => {
  return (options.client ?? client).get({
    requestValidator: async (data) => {
      return await zGetChannelBannedUsersData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zGetChannelBannedUsersResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-bans",
    ...options
  });
};
var banUserFromChannel = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zBanUserFromChannelData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zBanUserFromChannelResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-bans",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var unfollowChannel = (options) => {
  return (options.client ?? client).delete({
    requestValidator: async (data) => {
      return await zUnfollowChannelData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zUnfollowChannelResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-follows",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var followChannel = (options) => {
  return (options.client ?? client).post({
    requestValidator: async (data) => {
      return await zFollowChannelData.parseAsync(data);
    },
    responseValidator: async (data) => {
      return await zFollowChannelResponse.parseAsync(data);
    },
    security: [
      {
        scheme: "bearer",
        type: "http"
      }
    ],
    url: "/fc/channel-follows",
    ...options,
    headers: {
      "Content-Type": "application/json