import { FetchOptions, ResponseType, ofetch } from "ofetch";
import { z } from "zod";

//#region src/client/core/auth.gen.d.ts
type AuthToken = string | undefined;
interface Auth {
  /**
   * Which part of the request do we use to send the auth?
   *
   * @default 'header'
   */
  in?: "header" | "query" | "cookie";
  /**
   * Header or query parameter name.
   *
   * @default 'Authorization'
   */
  name?: string;
  scheme?: "basic" | "bearer";
  type: "apiKey" | "http";
}
//#endregion
//#region src/client/core/pathSerializer.gen.d.ts
interface SerializerOptions<T> {
  /**
   * @default true
   */
  explode: boolean;
  style: T;
}
type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
type ObjectStyle = "form" | "deepObject";
//#endregion
//#region src/client/core/bodySerializer.gen.d.ts
type QuerySerializer = (query: Record<string, unknown>) => string;
type BodySerializer = (body: any) => any;
type QuerySerializerOptionsObject = {
  allowReserved?: boolean;
  array?: Partial<SerializerOptions<ArrayStyle>>;
  object?: Partial<SerializerOptions<ObjectStyle>>;
};
type QuerySerializerOptions = QuerySerializerOptionsObject & {
  /**
   * Per-parameter serialization overrides. When provided, these settings
   * override the global array/object settings for specific parameter names.
   */
  parameters?: Record<string, QuerySerializerOptionsObject>;
};
declare const formDataBodySerializer: {
  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
};
declare const jsonBodySerializer: {
  bodySerializer: <T>(body: T) => string;
};
declare const urlSearchParamsBodySerializer: {
  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string;
};
//#endregion
//#region src/client/core/params.gen.d.ts
type Slot = "body" | "headers" | "path" | "query";
type Field = {
  in: Exclude<Slot, "body">;
  /**
   * Field name. This is the name we want the user to see and use.
   */
  key: string;
  /**
   * Field mapped name. This is the name we want to use in the request.
   * If omitted, we use the same value as `key`.
   */
  map?: string;
} | {
  in: Extract<Slot, "body">;
  /**
   * Key isn't required for bodies.
   */
  key?: string;
  map?: string;
} | {
  /**
   * Field name. This is the name we want the user to see and use.
   */
  key: string;
  /**
   * Field mapped name. This is the name we want to use in the request.
   * If `in` is omitted, `map` aliases `key` to the transport layer.
   */
  map: Slot;
};
interface Fields {
  allowExtra?: Partial<Record<Slot, boolean>>;
  args?: ReadonlyArray<Field>;
}
type FieldsConfig = ReadonlyArray<Field | Fields>;
interface Params {
  body: unknown;
  headers: Record<string, unknown>;
  path: Record<string, unknown>;
  query: Record<string, unknown>;
}
declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params;
//#endregion
//#region src/client/core/queryKeySerializer.gen.d.ts
/**
 * JSON-friendly union that mirrors what Pinia Colada can hash.
 */
type JsonValue = null | string | number | boolean | JsonValue[] | {
  [key: string]: JsonValue;
};
/**
 * Normalizes any accepted value into a JSON-friendly shape for query keys.
 */
declare const serializeQueryKeyValue: (value: unknown) => JsonValue | undefined;
//#endregion
//#region src/client/core/types.gen.d.ts
type HttpMethod = "connect" | "delete" | "get" | "head" | "options" | "patch" | "post" | "put" | "trace";
type Client$1<RequestFn$1 = never, Config$2 = unknown, MethodFn$1 = never, BuildUrlFn$1 = never, SseFn$1 = never> = {
  /**
   * Returns the final request URL.
   */
  buildUrl: BuildUrlFn$1;
  getConfig: () => Config$2;
  request: RequestFn$1;
  setConfig: (config: Config$2) => Config$2;
} & { [K in HttpMethod]: MethodFn$1 } & ([SseFn$1] extends [never] ? {
  sse?: never;
} : {
  sse: { [K in HttpMethod]: SseFn$1 };
});
interface Config$1 {
  /**
   * Auth token or a function returning auth token. The resolved value will be
   * added to the request payload as defined by its `security` array.
   */
  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
  /**
   * A function for serializing request body parameter. By default,
   * {@link JSON.stringify()} will be used.
   */
  bodySerializer?: BodySerializer | null;
  /**
   * An object containing any HTTP headers that you want to pre-populate your
   * `Headers` object with.
   *
   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
   */
  headers?: RequestInit["headers"] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
  /**
   * The request method.
   *
   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
   */
  method?: Uppercase<HttpMethod>;
  /**
   * A function for serializing request query parameters. By default, arrays
   * will be exploded in form style, objects will be exploded in deepObject
   * style, and reserved characters are percent-encoded.
   *
   * This method will have no effect if the native `paramsSerializer()` Axios
   * API function is used.
   *
   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
   */
  querySerializer?: QuerySerializer | QuerySerializerOptions;
  /**
   * A function validating request data. This is useful if you want to ensure
   * the request conforms to the desired shape, so it can be safely sent to
   * the server.
   */
  requestValidator?: (data: unknown) => Promise<unknown>;
  /**
   * A function transforming response data before it's returned. This is useful
   * for post-processing data, e.g. converting ISO strings into Date objects.
   */
  responseTransformer?: (data: unknown) => Promise<unknown>;
  /**
   * A function validating response data. This is useful if you want to ensure
   * the response conforms to the desired shape, so it can be safely passed to
   * the transformers and returned to the user.
   */
  responseValidator?: (data: unknown) => Promise<unknown>;
}
//#endregion
//#region src/client/core/serverSentEvents.gen.d.ts
type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method"> & Pick<Config$1, "method" | "responseTransformer" | "responseValidator"> & {
  /**
   * Fetch API implementation. You can use this option to provide a custom
   * fetch instance.
   *
   * @default globalThis.fetch
   */
  fetch?: typeof fetch;
  /**
   * Implementing clients can call request interceptors inside this hook.
   */
  onRequest?: (url: string, init: RequestInit) => Promise<Request>;
  /**
   * Callback invoked when a network or parsing error occurs during streaming.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @param error The error that occurred.
   */
  onSseError?: (error: unknown) => void;
  /**
   * Callback invoked when an event is streamed from the server.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @param event Event streamed from the server.
   * @returns Nothing (void).
   */
  onSseEvent?: (event: StreamEvent<TData>) => void;
  serializedBody?: RequestInit["body"];
  /**
   * Default retry delay in milliseconds.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @default 3000
   */
  sseDefaultRetryDelay?: number;
  /**
   * Maximum number of retry attempts before giving up.
   */
  sseMaxRetryAttempts?: number;
  /**
   * Maximum retry delay in milliseconds.
   *
   * Applies only when exponential backoff is used.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @default 30000
   */
  sseMaxRetryDelay?: number;
  /**
   * Optional sleep function for retry backoff.
   *
   * Defaults to using `setTimeout`.
   */
  sseSleepFn?: (ms: number) => Promise<void>;
  url: string;
};
interface StreamEvent<TData = unknown> {
  data: TData;
  event?: string;
  id?: string;
  retry?: number;
}
type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
  stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
};
//#endregion
//#region src/client/client/utils.gen.d.ts
declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
type ErrInterceptor<Err, Res, Req, Options$2> = (error: Err, response: Res, request: Req, options: Options$2) => Err | Promise<Err>;
type ReqInterceptor<Req, Options$2> = (request: Req, options: Options$2) => Req | Promise<Req>;
type ResInterceptor<Res, Req, Options$2> = (response: Res, request: Req, options: Options$2) => Res | Promise<Res>;
declare class Interceptors<Interceptor> {
  fns: Array<Interceptor | null>;
  clear(): void;
  eject(id: number | Interceptor): void;
  exists(id: number | Interceptor): boolean;
  getInterceptorIndex(id: number | Interceptor): number;
  update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
  use(fn: Interceptor): number;
}
interface Middleware<Req, Res, Err, Options$2> {
  error: Interceptors<ErrInterceptor<Err, Res, Req, Options$2>>;
  request: Interceptors<ReqInterceptor<Req, Options$2>>;
  response: Interceptors<ResInterceptor<Res, Req, Options$2>>;
}
declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>;
//#endregion
//#region src/client/client/types.gen.d.ts
type ResponseStyle = "data" | "fields";
interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, "body" | "headers" | "method">, Config$1 {
  /**
   * HTTP(S) agent configuration (Node.js only). Passed through to ofetch.
   */
  agent?: FetchOptions["agent"];
  /**
   * Base URL for all requests made by this client.
   */
  baseUrl?: T["baseUrl"];
  /**
   * Node-only proxy/agent options.
   */
  dispatcher?: FetchOptions["dispatcher"];
  /**
   * Fetch API implementation. Used for SSE streaming. You can use this option
   * to provide a custom fetch instance.
   *
   * @default globalThis.fetch
   */
  fetch?: typeof fetch;
  /**
   * Controls the native ofetch behaviour that throws `FetchError` when
   * `response.ok === false`. We default to suppressing it to match the fetch
   * client semantics and let `throwOnError` drive the outcome.
   */
  ignoreResponseError?: FetchOptions["ignoreResponseError"];
  /**
   * Please don't use the Fetch client for Next.js applications. The `next`
   * options won't have any effect.
   *
   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
   */
  next?: never;
  /**
   * Custom ofetch instance created via `ofetch.create()`. If provided, it will
   * be used for requests instead of the default `ofetch` export.
   */
  ofetch?: typeof ofetch;
  /**
   * ofetch hook called before a request is sent.
   */
  onRequest?: FetchOptions["onRequest"];
  /**
   * ofetch hook called when a request fails before receiving a response
   * (e.g., network errors or aborted requests).
   */
  onRequestError?: FetchOptions["onRequestError"];
  /**
   * ofetch hook called after a successful response is received and parsed.
   */
  onResponse?: FetchOptions["onResponse"];
  /**
   * ofetch hook called when the response indicates an error (non-ok status)
   * or when response parsing fails.
   */
  onResponseError?: FetchOptions["onResponseError"];
  /**
   * Return the response data parsed in a specified format. By default, `auto`
   * will infer the appropriate method from the `Content-Type` response header.
   * You can override this behavior with any of the {@link Body} methods.
   * Select `stream` if you don't want to parse response data at all.
   *
   * @default 'auto'
   */
  parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text";
  /** Custom response parser (ofetch). */
  parseResponse?: FetchOptions["parseResponse"];
  /**
   * Should we return only data or multiple fields (data, error, response, etc.)?
   *
   * @default 'fields'
   */
  responseStyle?: ResponseStyle;
  /**
   * ofetch responseType override. If provided, it will be passed directly to
   * ofetch and take precedence over `parseAs`.
   */
  responseType?: ResponseType;
  /**
   * Automatically retry failed requests.
   */
  retry?: FetchOptions["retry"];
  /**
   * Delay (in ms) between retry attempts.
   */
  retryDelay?: FetchOptions["retryDelay"];
  /**
   * HTTP status codes that should trigger a retry.
   */
  retryStatusCodes?: FetchOptions["retryStatusCodes"];
  /**
   * Throw an error instead of returning it in the response?
   *
   * @default false
   */
  throwOnError?: T["throwOnError"];
  /**
   * Abort the request after the given milliseconds.
   */
  timeout?: number;
}
interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
  responseStyle: TResponseStyle;
  throwOnError: ThrowOnError;
}>, Pick<ServerSentEventsOptions<TData>, "onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"> {
  /**
   * Any body that you want to add to your request.
   *
   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
   */
  body?: unknown;
  path?: Record<string, unknown>;
  query?: Record<string, unknown>;
  /**
   * Security mechanism(s) to use for the request.
   */
  security?: ReadonlyArray<Auth>;
  url: Url;
}
interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
  serializedBody?: string;
}
type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = "fields"> = ThrowOnError extends true ? Promise<TResponseStyle extends "data" ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
  request: Request;
  response: Response;
}> : Promise<TResponseStyle extends "data" ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
  error: undefined;
} | {
  data: undefined;
  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
}) & {
  request: Request;
  response: Response;
}>;
interface ClientOptions {
  baseUrl?: string;
  responseStyle?: ResponseStyle;
  throwOnError?: boolean;
}
type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type BuildUrlFn = <TData extends {
  body?: unknown;
  path?: Record<string, unknown>;
  query?: Record<string, unknown>;
  url: string;
}>(options: TData & Options<TData>) => string;
type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
};
/**
 * The `createClientConfig()` function will be called on client initialization
 * and the returned object will become the client's initial configuration.
 *
 * You may want to initialize your client this way instead of calling
 * `setConfig()`. This is useful for example if you're using Next.js
 * to ensure your client always has the correct values.
 */
type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
interface TDataShape {
  body?: unknown;
  headers?: unknown;
  path?: unknown;
  query?: unknown;
  url: string;
}
type OmitKeys<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = "fields"> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> & ([TData] extends [never] ? unknown : Omit<TData, "url">);
//#endregion
//#region src/client/client/client.gen.d.ts
declare const createClient: (config?: Config) => Client;
//#endregion
//#region src/client/types.gen.d.ts
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;
  };
};
/**
 * Generic 400 Bad Request error for simple error messages
 */
type GenericBadRequestError = {
  errors: Array<{
    /**
     * Error message describing the issue
     */
    message: string;
  }>;
};
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: {
    /**
     * Notification items for the requested tab.
     */
    notifications: Array<{
      /**
       * Notification identifier.
       */
      id: string;
      /**
       * Notification type.
       */
      type: "channel-pinned-cast" | "channel-role-invite" | "new-cast-in-channel" | "cast-mention" | "cast-quote" | "cast-reaction" | "cast-reply" | "dormant-user-new-cast" | "follow" | "mini-app" | "new-article" | "new-cast" | "recast";
      /**
       * Latest activity timestamp (ms).
       */
      latestTimestamp: bigint;
      /**
       * Number of items represented by this notification.
       */
      totalItemCount: number;
      /**
       * Sample items for this notification; structure varies by type.
       */
      previewItems: Array<{
        [key: string]: unknown;
      }>;
      /**
       * Whether the notification is unread.
       */
      isUnread: boolean;
      /**
       * Additional notification-specific fields.
       */
      metadata?: {
        [key: string]: unknown;
      };
    }>;
    next?: PaginationCursor;
  };
};
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: bigint;
      currentPeriodStartTimestamp: bigint;
      currentPeriodEndTimestamp: bigint;
      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;
};
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 = {
  /**
   * Missing or invalid authorization header
   */
  400: GenericBadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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 for pagination
     */
    cursor?: string;
  };
  url: "/v2/direct-cast-inbox";
};
type GetDirectCastInboxErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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 (can be empty array)
     */
    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 = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * The specified resource was not found
   */
  404: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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;
    /**
     * Whether to randomize the suggested users
     */
    randomized?: boolean;
  };
  url: "/v2/suggested-users";
};
type GetSuggestedUsersErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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 = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * The specified resource was not found
   */
  404: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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" | "mentions" | "moderate";
    /**
     * Number of notifications to return
     */
    limit?: number;
    /**
     * Pagination cursor returned by a previous call
     */
    cursor?: string;
  };
  url: "/v1/notifications-for-tab";
};
type GetNotificationsErrors = {
  /**
   * Bad request - generic error
   */
  400: GenericBadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * The specified resource was not found
   */
  404: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 items to return
     */
    limit?: number;
  };
  url: "/v2/discover-channels";
};
type DiscoverChannelsErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetSponsoredInvitesError = GetSponsoredInvitesErrors[keyof GetSponsoredInvitesErrors];
type GetSponsoredInvitesResponses = {
  /**
   * List of sponsored invites
   */
  200: SponsoredInvitesResponse;
};
type GetSponsoredInvitesResponse = GetSponsoredInvitesResponses[keyof GetSponsoredInvitesResponses];
type GetOrCreateReferralCodeData = {
  /**
   * Empty request body
   */
  body: {
    [key: string]: never;
  };
  path?: never;
  query?: never;
  url: "/v2/get-or-create-referral-code";
};
type GetOrCreateReferralCodeErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetOrCreateReferralCodeError = GetOrCreateReferralCodeErrors[keyof GetOrCreateReferralCodeErrors];
type GetOrCreateReferralCodeResponses = {
  /**
   * Referral code retrieved or created successfully
   */
  200: {
    result: {
      /**
       * The referral code
       */
      code: string;
      /**
       * The unique identifier for the referral code
       */
      id: string;
    };
  };
};
type GetOrCreateReferralCodeResponse = GetOrCreateReferralCodeResponses[keyof GetOrCreateReferralCodeResponses];
type GetRewardsLeaderboardData = {
  body?: never;
  path?: never;
  query: {
    /**
     * Maximum number of items to return
     */
    limit?: number;
    /**
     * Type of rewards to retrieve
     */
    rewardsType: "invite";
    /**
     * Base64 encoded cursor for pagination
     */
    cursor?: string;
  };
  url: "/v2/rewards-leaderboard";
};
type GetRewardsLeaderboardErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
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 - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetRewardsMetadataError = GetRewardsMetadataErrors[keyof GetRewardsMetadataErrors];
type GetRewardsMetadataResponses = {
  /**
   * Invite rewards metadata
   */
  200: RewardsMetadataResponse;
};
type GetRewardsMetadataResponse = GetRewardsMetadataResponses[keyof GetRewardsMetadataResponses];
type GetXpRewardsData = {
  body?: never;
  path?: never;
  query?: {
    /**
     * Maximum number of rewards to return
     */
    limit?: number;
  };
  url: "/v2/xp-rewards";
};
type GetXpRewardsErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetXpRewardsError = GetXpRewardsErrors[keyof GetXpRewardsErrors];
type GetXpRewardsResponses = {
  /**
   * XP rewards retrieved successfully
   */
  200: {
    result: {
      /**
       * List of reward items
       */
      rewards: Array<{
        [key: string]: unknown;
      }>;
      /**
       * Total USDC earned from rewards
       */
      totalUsdc: number;
      /**
       * Total number of referrals
       */
      totalReferrals: number;
    };
  };
};
type GetXpRewardsResponse = GetXpRewardsResponses[keyof GetXpRewardsResponses];
type GetXpClaimableSummaryData = {
  /**
   * Empty request body
   */
  body: {
    [key: string]: never;
  };
  path?: never;
  query?: never;
  url: "/v2/xp-claimable-summary";
};
type GetXpClaimableSummaryErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetXpClaimableSummaryError = GetXpClaimableSummaryErrors[keyof GetXpClaimableSummaryErrors];
type GetXpClaimableSummaryResponses = {
  /**
   * XP claimable summary retrieved successfully
   */
  200: {
    result: {
      /**
       * Total USDC amount available to claim
       */
      totalClaimableUsdc: number;
      /**
       * Number of pending rewards
       */
      pendingRewardsCount: number;
      /**
       * Whether the user is eligible to claim rewards
       */
      eligibleToClaim: boolean;
      /**
       * Reason why user is ineligible to claim (if applicable)
       */
      ineligibleToClaimReason?: string;
    };
  };
};
type GetXpClaimableSummaryResponse = GetXpClaimableSummaryResponses[keyof GetXpClaimableSummaryResponses];
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;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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: {
    /**
     * The user's FID (Farcaster ID)
     */
    fid: number;
    /**
     * Maximum number of items to return
     */
    limit?: number;
  };
  url: "/v2/starter-packs";
};
type GetUserStarterPacksErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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: {
    /**
     * The unique identifier of the starter pack
     */
    id: string;
  };
  url: "/v2/starter-pack";
};
type GetStarterPackErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * The specified resource was not found
   */
  404: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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: {
    /**
     * The unique key identifier for the channel
     */
    key: string;
  };
  url: "/v2/channel";
};
type GetChannelErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * The specified resource was not found
   */
  404: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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: {
    /**
     * The user's FID (Farcaster ID)
     */
    fid: number;
    /**
     * Maximum number of items to return
     */
    limit?: number;
  };
  url: "/v2/following";
};
type GetFollowingErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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: {
    /**
     * The user's FID (Farcaster ID)
     */
    fid: number;
    /**
     * Maximum number of items to return
     */
    limit?: number;
  };
  url: "/v2/followers";
};
type GetFollowersErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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;
    /**
     * Search query string
     */
    q?: string;
    /**
     * Whether to prioritize channels the user follows
     */
    prioritizeFollowed?: boolean;
    /**
     * Whether the search is for the composer context
     */
    forComposer?: boolean;
  };
  url: "/v2/search-channels";
};
type SearchChannelsErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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: {
    /**
     * The hash of the cast to delete
     */
    castHash: string;
  };
  path?: never;
  query?: never;
  url: "/v2/casts";
};
type DeleteCastErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * The specified resource was not found
   */
  404: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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 user's FID (Farcaster ID)
     */
    fid: number;
    /**
     * Maximum number of items to return
     */
    limit?: number;
  };
  url: "/v2/casts";
};
type GetCastsByFidErrors = {
  /**
   * Bad request
   */
  400: ErrorResponse;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetCastsByFidError = GetCastsByFidErrors[keyof GetCastsByFidErrors];
type GetCastsByFidResponses = {
  /**
   * Successfully retrieved casts
   */
  200: {
    result?: {
      casts?: Array<Cast>;
    };
  };
};
type GetCastsByFidResponse = GetCastsByFidResponses[keyof GetCastsByFidResponses];
type CreateCastData = {
  body: {
    /**
     * The text content of the cast
     */
    text: string;
    /**
     * Optional array of embeds (URLs, images, etc.)
     */
    embeds?: Array<string | {
      [key: string]: unknown;
    }>;
    /**
     * Optional channel to post the cast to
     */
    channelKey?: string;
  };
  path?: never;
  query?: never;
  url: "/v2/casts";
};
type CreateCastErrors = {
  /**
   * Bad request - validation errors or malformed request
   */
  400: BadRequestError;
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: 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 = {
  /**
   * Bad request - generic error
   */
  400: GenericBadRequestError;
};
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 GetTrendingTopicsData = {
  body?: never;
  path?: never;
  query?: never;
  url: "/v1/get-trending-topics";
};
type GetTrendingTopicsErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetTrendingTopicsError = GetTrendingTopicsErrors[keyof GetTrendingTopicsErrors];
type GetTrendingTopicsResponses = {
  /**
   * Trending topics retrieved successfully
   */
  200: {
    result: {
      /**
       * List of trending topics
       */
      topics: Array<{
        [key: string]: unknown;
      }>;
    };
  };
};
type GetTrendingTopicsResponse = GetTrendingTopicsResponses[keyof GetTrendingTopicsResponses];
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 GetManagedAppsData = {
  body?: never;
  path?: never;
  query?: {
    /**
     * Maximum number of apps to return
     */
    limit?: number;
  };
  url: "/v1/dev-tools/managed-apps";
};
type GetManagedAppsErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type GetManagedAppsError = GetManagedAppsErrors[keyof GetManagedAppsErrors];
type GetManagedAppsResponses = {
  /**
   * Managed apps retrieved successfully
   */
  200: {
    result: {
      /**
       * List of managed apps
       */
      apps: Array<{
        [key: string]: unknown;
      }>;
    };
  };
};
type GetManagedAppsResponse = GetManagedAppsResponses[keyof GetManagedAppsResponses];
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 SubmitAnalyticsEventsData = {
  body: {
    /**
     * Array of analytics events to submit
     */
    events: Array<{
      /**
       * Type of the analytics event
       */
      type: string;
      /**
       * Event-specific data
       */
      data: {
        [key: string]: unknown;
      };
      /**
       * Unix timestamp in milliseconds when the event occurred
       */
      ts: bigint;
    }>;
  };
  path?: never;
  query?: never;
  url: "/v1/analytics-events";
};
type SubmitAnalyticsEventsErrors = {
  /**
   * Authentication is required or failed
   */
  401: ErrorResponse;
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type SubmitAnalyticsEventsError = SubmitAnalyticsEventsErrors[keyof SubmitAnalyticsEventsErrors];
type SubmitAnalyticsEventsResponses = {
  /**
   * Analytics events submitted successfully
   */
  200: SuccessResponse;
};
type SubmitAnalyticsEventsResponse = SubmitAnalyticsEventsResponses[keyof SubmitAnalyticsEventsResponses];
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 RegisterStatsigEventsData = {
  body: {
    /**
     * Array of Statsig events to submit
     */
    events: Array<{
      /**
       * Name of the event
       */
      eventName: string;
      /**
       * User information
       */
      user: {
        /**
         * User ID
         */
        userID?: number;
        /**
         * Application version
         */
        appVersion?: string;
        statsigEnvironment?: {
          /**
           * Environment tier
           */
          tier?: string;
        };
      };
      /**
       * Event value
       */
      value?: string | null;
      /**
       * Event metadata
       */
      metadata?: {
        [key: string]: unknown;
      };
      /**
       * Unix timestamp in milliseconds when the event occurred
       */
      time: bigint;
      /**
       * Additional Statsig metadata
       */
      statsigMetadata?: {
        [key: string]: unknown;
      };
      /**
       * Secondary exposures
       */
      secondaryExposures?: Array<{
        [key: string]: unknown;
      }>;
    }>;
    /**
     * SDK metadata
     */
    statsigMetadata?: {
      /**
       * Type of SDK
       */
      sdkType?: string;
      /**
       * Version of SDK
       */
      sdkVersion?: string;
      /**
       * Stable ID for the client
       */
      stableID?: string;
    };
  };
  path?: never;
  query?: never;
  url: "/v2/ss/v1/rgstr";
};
type RegisterStatsigEventsErrors = {
  /**
   * Too many requests - rate limit exceeded
   */
  429: ErrorResponse;
};
type RegisterStatsigEventsError = RegisterStatsigEventsErrors[keyof RegisterStatsigEventsErrors];
type RegisterStatsigEventsResponses = {
  /**
   * Events registered successfully
   */
  200: {
    /**
     * Whether the events were successfully registered
     */
    success: boolean;
  };
};
type RegisterStatsigEventsResponse = RegisterStatsigEventsResponses[keyof RegisterStatsigEventsResponses];
//#endregion
//#region src/client/client.gen.d.ts
declare const client: Client;
//#endregion
//#region src/client/schemas.gen.d.ts
declare const ProfilePictureSchema: {
  readonly type: "object";
  readonly properties: {
    readonly url: {
      readonly type: "string";
      readonly format: "uri";
    };
    readonly verified: {
      readonly type: "boolean";
    };
  };
};
declare const BioSchema: {
  readonly type: "object";
  readonly properties: {
    readonly text: {
      readonly type: "string";
    };
    readonly mentions: {
      readonly type: "array";
      readonly items: {};
    };
    readonly channelMentions: {
      readonly type: "array";
      readonly items: {};
    };
  };
};
declare const LocationSchema: {
  readonly type: "object";
  readonly properties: {
    readonly placeId: {
      readonly type: "string";
    };
    readonly description: {
      readonly type: "string";
    };
  };
};
declare const ProfileSchema: {
  readonly type: "object";
  readonly properties: {
    readonly bio: {
      readonly $ref: "#/components/schemas/Bio";
    };
    readonly location: {
      readonly $ref: "#/components/schemas/Location";
    };
  };
};
declare const ViewerContextSchema: {
  readonly type: "object";
  readonly properties: {
    readonly following: {
      readonly type: "boolean";
    };
    readonly followedBy: {
      readonly type: "boolean";
    };
    readonly enableNotifications: {
      readonly type: "boolean";
    };
    readonly canSendDirectCasts: {
      readonly type: "boolean";
    };
    readonly hasUploadedInboxKeys: {
      readonly type: "boolean";
    };
  };
};
declare const UserSchema: {
  readonly type: "object";
  readonly required: readonly ["fid", "displayName", "username"];
  readonly properties: {
    readonly fid: {
      readonly type: "integer";
    };
    readonly username: {
      readonly type: "string";
    };
    readonly displayName: {
      readonly type: "string";
    };
    readonly pfp: {
      readonly $ref: "#/components/schemas/ProfilePicture";
    };
    readonly profile: {
      readonly $ref: "#/components/schemas/Profile";
    };
    readonly followerCount: {
      readonly type: "integer";
    };
    readonly followingCount: {
      readonly type: "integer";
    };
    readonly viewerContext: {
      readonly $ref: "#/components/schemas/ViewerContext";
    };
  };
};
declare const OnboardingStateSchema: {
  readonly type: "object";
  readonly properties: {
    readonly id: {
      readonly type: "string";
      readonly format: "uuid";
    };
    readonly email: {
      readonly type: "string";
      readonly format: "email";
    };
    readonly user: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly hasOnboarding: {
      readonly type: "boolean";
    };
    readonly hasConfirmedEmail: {
      readonly type: "boolean";
    };
    readonly handledConnectAddress: {
      readonly type: "boolean";
    };
    readonly canRegisterUsername: {
      readonly type: "boolean";
    };
    readonly needsRegistrationPayment: {
      readonly type: "boolean";
    };
    readonly hasFid: {
      readonly type: "boolean";
    };
    readonly hasFname: {
      readonly type: "boolean";
    };
    readonly hasDelegatedSigner: {
      readonly type: "boolean";
    };
    readonly hasSetupProfile: {
      readonly type: "boolean";
    };
    readonly hasCompletedRegistration: {
      readonly type: "boolean";
    };
    readonly hasStorage: {
      readonly type: "boolean";
    };
    readonly handledPushNotificationsNudge: {
      readonly type: "boolean";
    };
    readonly handledContactsNudge: {
      readonly type: "boolean";
    };
    readonly handledInterestsNudge: {
      readonly type: "boolean";
    };
    readonly hasValidPaidInvite: {
      readonly type: "boolean";
    };
    readonly hasWarpcastWalletAddress: {
      readonly type: "boolean";
    };
    readonly hasPhone: {
      readonly type: "boolean";
    };
    readonly needsPhone: {
      readonly type: "boolean";
    };
    readonly sponsoredRegisterEligible: {
      readonly type: "boolean";
    };
    readonly geoRestricted: {
      readonly type: "boolean";
    };
  };
};
declare const OnboardingStateResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly state: {
          readonly $ref: "#/components/schemas/OnboardingState";
        };
      };
    };
  };
};
declare const GenericBadRequestErrorSchema: {
  readonly type: "object";
  readonly description: "Generic 400 Bad Request error for simple error messages";
  readonly properties: {
    readonly errors: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly properties: {
          readonly message: {
            readonly type: "string";
            readonly description: "Error message describing the issue";
          };
        };
        readonly required: readonly ["message"];
      };
    };
  };
  readonly required: readonly ["errors"];
};
declare const ErrorResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly errors: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly properties: {
          readonly message: {
            readonly type: "string";
            readonly description: "Error message describing the issue";
          };
        };
      };
    };
  };
};
declare const UserWithExtrasSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/User";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly connectedAccounts: {
        readonly type: "array";
        readonly items: {};
      };
    };
  }];
};
declare const UserExtrasSchema: {
  readonly type: "object";
  readonly properties: {
    readonly fid: {
      readonly type: "integer";
    };
    readonly custodyAddress: {
      readonly type: "string";
    };
    readonly ethWallets: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
    };
    readonly solanaWallets: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
    };
    readonly walletLabels: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly properties: {
          readonly address: {
            readonly type: "string";
          };
          readonly labels: {
            readonly type: "array";
            readonly items: {
              readonly type: "string";
            };
          };
        };
      };
    };
    readonly v2: {
      readonly type: "boolean";
    };
    readonly publicSpamLabel: {
      readonly type: "string";
    };
  };
};
declare const UserByFidResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly user: {
          readonly $ref: "#/components/schemas/UserWithExtras";
        };
        readonly collectionsOwned: {
          readonly type: "array";
          readonly items: {};
        };
        readonly extras: {
          readonly $ref: "#/components/schemas/UserExtras";
        };
      };
    };
  };
};
declare const ValidationErrorSchema: {
  readonly type: "object";
  readonly description: "Represents a single validation error";
  readonly properties: {
    readonly instancePath: {
      readonly type: "string";
      readonly description: "JSON Pointer to the part of the request that failed validation";
      readonly example: "/fid";
    };
    readonly schemaPath: {
      readonly type: "string";
      readonly description: "JSON Schema path that was violated";
      readonly example: "ApiFid/type";
    };
    readonly keyword: {
      readonly type: "string";
      readonly description: "The JSON Schema keyword that failed";
      readonly example: "type";
    };
    readonly params: {
      readonly type: "object";
      readonly description: "Additional parameters describing the validation error";
      readonly additionalProperties: true;
      readonly example: {
        readonly type: "integer";
      };
    };
    readonly message: {
      readonly type: "string";
      readonly description: "Human-readable error description";
      readonly example: "must be integer";
    };
  };
  readonly required: readonly ["instancePath", "schemaPath", "keyword", "message"];
};
declare const BadRequestErrorSchema: {
  readonly type: "object";
  readonly description: "Standard 400 Bad Request error response";
  readonly properties: {
    readonly errors: {
      readonly type: "array";
      readonly description: "Array of validation errors";
      readonly items: {
        readonly $ref: "#/components/schemas/ValidationError";
      };
    };
  };
  readonly required: readonly ["errors"];
};
declare const DirectCastMessageReactionSchema: {
  readonly type: "object";
  readonly required: readonly ["reaction", "count"];
  readonly properties: {
    readonly reaction: {
      readonly type: "string";
      readonly description: "Emoji used for the reaction";
      readonly example: "🔥";
    };
    readonly count: {
      readonly type: "integer";
      readonly minimum: 1;
      readonly description: "Number of users who reacted with this emoji";
      readonly example: 3;
    };
    readonly emoji: {
      readonly type: "string";
      readonly description: "Emoji used for the reaction (legacy field)";
    };
    readonly userFids: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
      readonly description: "List of Farcaster IDs who reacted";
    };
  };
};
declare const DirectCastMessageViewerContextSchema: {
  readonly type: "object";
  readonly properties: {
    readonly isLastReadMessage: {
      readonly type: "boolean";
      readonly description: "Whether this is the last read message";
      readonly example: false;
    };
    readonly focused: {
      readonly type: "boolean";
      readonly description: "Whether the message is focused";
      readonly example: false;
    };
    readonly reactions: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
      readonly description: "User's reactions to this message";
    };
  };
};
declare const DirectCastMessageSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "senderFid", "messageId", "serverTimestamp", "type", "message", "hasMention", "reactions", "isPinned", "isDeleted", "senderContext"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation this message belongs to";
    };
    readonly senderFid: {
      readonly type: "integer";
      readonly description: "Farcaster ID of the message sender";
    };
    readonly messageId: {
      readonly type: "string";
      readonly description: "Unique identifier for the message";
    };
    readonly serverTimestamp: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Server timestamp when message was sent (Unix milliseconds)";
      readonly example: 1753112479748;
    };
    readonly type: {
      readonly type: "string";
      readonly enum: readonly ["text", "image", "reaction", "link", "group_membership_addition", "pin_message", "message_ttl_change"];
      readonly description: "Type of the message";
      readonly example: "text";
    };
    readonly message: {
      readonly type: "string";
      readonly description: "Content of the message";
    };
    readonly hasMention: {
      readonly type: "boolean";
      readonly description: "Whether the message contains mentions";
      readonly example: false;
    };
    readonly reactions: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/DirectCastMessageReaction";
      };
      readonly description: "List of reactions to the message";
    };
    readonly isPinned: {
      readonly type: "boolean";
      readonly description: "Whether the message is pinned";
      readonly example: false;
    };
    readonly isDeleted: {
      readonly type: "boolean";
      readonly description: "Whether the message is deleted";
      readonly example: false;
    };
    readonly senderContext: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly viewerContext: {
      readonly $ref: "#/components/schemas/DirectCastMessageViewerContext";
    };
    readonly inReplyTo: {
      readonly $ref: "#/components/schemas/DirectCastMessage";
    };
    readonly metadata: {
      readonly $ref: "#/components/schemas/DirectCastMessageMetadata";
    };
    readonly actionTargetUserContext: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly isProgrammatic: {
      readonly type: "boolean";
      readonly description: "Whether the message was sent programmatically";
      readonly example: false;
    };
    readonly mentions: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/DirectCastMessageMention";
      };
      readonly description: "List of mentions in the message";
    };
  };
};
declare const DirectCastMessageMetadataSchema: {
  readonly type: "object";
  readonly properties: {
    readonly casts: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly additionalProperties: true;
      };
      readonly description: "Cast metadata if message contains cast references";
    };
    readonly urls: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly additionalProperties: true;
      };
      readonly description: "URL metadata if message contains links";
    };
    readonly medias: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly additionalProperties: true;
      };
      readonly description: "Media metadata if message contains media";
    };
  };
};
declare const DirectCastMessageMentionSchema: {
  readonly type: "object";
  readonly required: readonly ["user", "textIndex", "length"];
  readonly properties: {
    readonly user: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly textIndex: {
      readonly type: "integer";
      readonly description: "Starting index of the mention in the message text";
      readonly example: 19;
    };
    readonly length: {
      readonly type: "integer";
      readonly description: "Length of the mention text";
      readonly example: 8;
    };
  };
};
declare const DirectCastConversationViewerContextSchema: {
  readonly type: "object";
  readonly properties: {
    readonly access: {
      readonly type: "string";
      readonly enum: readonly ["read-write", "read-only"];
      readonly description: "Access level for the conversation";
      readonly example: "read-write";
    };
    readonly category: {
      readonly type: "string";
      readonly description: "Category of the conversation";
      readonly example: "default";
    };
    readonly archived: {
      readonly type: "boolean";
      readonly description: "Whether the conversation is archived";
      readonly example: false;
    };
    readonly lastReadAt: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Timestamp of last read (Unix milliseconds)";
      readonly example: 1753650746109;
    };
    readonly muted: {
      readonly type: "boolean";
      readonly description: "Whether the conversation is muted";
      readonly example: false;
    };
    readonly manuallyMarkedUnread: {
      readonly type: "boolean";
      readonly description: "Whether the conversation is manually marked as unread";
      readonly example: false;
    };
    readonly pinned: {
      readonly type: "boolean";
      readonly description: "Whether the conversation is pinned";
      readonly example: false;
    };
    readonly unreadCount: {
      readonly type: "integer";
      readonly minimum: 0;
      readonly description: "Number of unread messages";
      readonly example: 0;
    };
    readonly unreadMentionsCount: {
      readonly type: "integer";
      readonly minimum: 0;
      readonly description: "Number of unread mentions";
      readonly example: 0;
    };
    readonly counterParty: {
      readonly $ref: "#/components/schemas/User";
      readonly description: "The other participant in a 1:1 conversation";
    };
    readonly tag: {
      readonly type: "string";
      readonly description: "Tag associated with the conversation";
      readonly example: "automated";
    };
  };
};
declare const DirectCastConversationSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "isGroup", "createdAt", "viewerContext", "adminFids", "lastReadTime"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "Unique identifier for the conversation";
    };
    readonly name: {
      readonly type: "string";
      readonly description: "Name of the conversation (for group conversations)";
    };
    readonly description: {
      readonly type: "string";
      readonly description: "Description of the conversation";
    };
    readonly photoUrl: {
      readonly type: "string";
      readonly format: "uri";
      readonly description: "URL of the conversation photo";
    };
    readonly adminFids: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
      readonly description: "List of admin Farcaster IDs";
    };
    readonly removedFids: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
      readonly description: "List of removed Farcaster IDs";
    };
    readonly participants: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/User";
      };
      readonly description: "List of conversation participants";
    };
    readonly lastReadTime: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Timestamp of last read time (Unix milliseconds)";
      readonly example: 1741871452933;
    };
    readonly selfLastReadTime: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Timestamp of viewer's last read time (Unix milliseconds)";
      readonly example: 1753650746109;
    };
    readonly pinnedMessages: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/DirectCastMessage";
      };
      readonly description: "List of pinned messages in the conversation";
    };
    readonly hasPinnedMessages: {
      readonly type: "boolean";
      readonly description: "Whether the conversation has pinned messages";
      readonly example: false;
    };
    readonly isGroup: {
      readonly type: "boolean";
      readonly description: "Whether this is a group conversation";
      readonly example: true;
    };
    readonly isCollectionTokenGated: {
      readonly type: "boolean";
      readonly description: "Whether the conversation is collection token gated";
      readonly example: false;
    };
    readonly activeParticipantsCount: {
      readonly type: "integer";
      readonly minimum: 0;
      readonly description: "Number of active participants in the conversation";
      readonly example: 2;
    };
    readonly messageTTLDays: {
      readonly oneOf: readonly [{
        readonly type: "integer";
        readonly minimum: 0;
        readonly description: "Number of days until message expires";
      }, {
        readonly type: "string";
        readonly enum: readonly ["Infinity"];
        readonly description: "Messages never expire";
      }];
      readonly description: "Message time-to-live in days, or \"Infinity\" for no expiration";
      readonly examples: readonly [365, "Infinity"];
    };
    readonly createdAt: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Timestamp when conversation was created (Unix milliseconds)";
      readonly example: 1709952982363;
    };
    readonly unreadCount: {
      readonly type: "integer";
      readonly minimum: 0;
      readonly description: "Number of unread messages";
      readonly example: 0;
    };
    readonly muted: {
      readonly type: "boolean";
      readonly description: "Whether the conversation is muted";
      readonly example: false;
    };
    readonly hasMention: {
      readonly type: "boolean";
      readonly description: "Whether the conversation has mentions";
      readonly example: false;
    };
    readonly lastMessage: {
      readonly $ref: "#/components/schemas/DirectCastMessage";
    };
    readonly viewerContext: {
      readonly $ref: "#/components/schemas/DirectCastConversationViewerContext";
    };
  };
};
declare const DirectCastInboxResultSchema: {
  readonly type: "object";
  readonly required: readonly ["hasArchived", "hasUnreadRequests", "requestsCount", "conversations"];
  readonly properties: {
    readonly hasArchived: {
      readonly type: "boolean";
      readonly description: "Whether user has archived conversations";
      readonly example: false;
    };
    readonly hasUnreadRequests: {
      readonly type: "boolean";
      readonly description: "Whether user has unread conversation requests";
      readonly example: false;
    };
    readonly requestsCount: {
      readonly type: "integer";
      readonly minimum: 0;
      readonly description: "Total number of conversation requests";
      readonly example: 12;
    };
    readonly conversations: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/DirectCastConversation";
      };
    };
  };
};
declare const PaginationCursorSchema: {
  readonly type: "object";
  readonly properties: {
    readonly cursor: {
      readonly type: "string";
      readonly description: "Base64 encoded cursor for pagination";
    };
  };
  readonly additionalProperties: true;
};
declare const DirectCastInboxResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly $ref: "#/components/schemas/DirectCastInboxResult";
    };
    readonly next: {
      readonly $ref: "#/components/schemas/PaginationCursor";
    };
  };
};
declare const CastActionSchema: {
  readonly type: "object";
  readonly properties: {
    readonly id: {
      readonly type: "string";
    };
    readonly name: {
      readonly type: "string";
    };
    readonly octicon: {
      readonly type: "string";
    };
    readonly actionUrl: {
      readonly type: "string";
    };
    readonly action: {
      readonly type: "object";
      readonly properties: {
        readonly actionType: {
          readonly type: "string";
        };
        readonly postUrl: {
          readonly type: "string";
        };
      };
    };
  };
};
declare const UserAppContextResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly context: {
          readonly type: "object";
          readonly properties: {
            readonly canAddLinks: {
              readonly type: "boolean";
            };
            readonly showConnectedApps: {
              readonly type: "boolean";
            };
            readonly signerRequestsEnabled: {
              readonly type: "boolean";
            };
            readonly prompts: {
              readonly type: "array";
              readonly items: {};
            };
            readonly adminForChannelKeys: {
              readonly type: "array";
              readonly items: {
                readonly type: "string";
              };
            };
            readonly modOfChannelKeys: {
              readonly type: "array";
              readonly items: {
                readonly type: "string";
              };
            };
            readonly memberOfChannelKeys: {
              readonly type: "array";
              readonly items: {
                readonly type: "string";
              };
            };
            readonly canEditAllChannels: {
              readonly type: "boolean";
            };
            readonly canUploadVideo: {
              readonly type: "boolean";
            };
            readonly statsigEnabled: {
              readonly type: "boolean";
            };
            readonly shouldPromptForPushNotifications: {
              readonly type: "boolean";
            };
            readonly shouldPromptForUserFollowsSyncContacts: {
              readonly type: "boolean";
            };
            readonly castActions: {
              readonly type: "array";
              readonly items: {
                readonly $ref: "#/components/schemas/CastAction";
              };
            };
            readonly canAddCastAction: {
              readonly type: "boolean";
            };
            readonly enabledCastAction: {
              readonly $ref: "#/components/schemas/CastAction";
            };
            readonly notificationTabsV2: {
              readonly type: "array";
              readonly items: {
                readonly type: "object";
                readonly properties: {
                  readonly id: {
                    readonly type: "string";
                  };
                  readonly name: {
                    readonly type: "string";
                  };
                };
              };
            };
            readonly enabledVideoAutoplay: {
              readonly type: "boolean";
            };
            readonly regularCastByteLimit: {
              readonly type: "integer";
            };
            readonly longCastByteLimit: {
              readonly type: "integer";
            };
            readonly newUserStatus: {
              readonly type: "object";
            };
            readonly country: {
              readonly type: "string";
            };
            readonly higherClientEventSamplingRateEnabled: {
              readonly type: "boolean";
            };
          };
        };
      };
    };
  };
};
declare const UserPreferencesResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly preferences: {
          readonly type: "object";
          readonly additionalProperties: true;
        };
      };
    };
  };
};
declare const ChannelSchema: {
  readonly type: "object";
  readonly properties: {
    readonly type: {
      readonly type: "string";
    };
    readonly key: {
      readonly type: "string";
    };
    readonly name: {
      readonly type: "string";
    };
    readonly imageUrl: {
      readonly type: "string";
    };
    readonly fastImageUrl: {
      readonly type: "string";
    };
    readonly feeds: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly properties: {
          readonly name: {
            readonly type: "string";
          };
          readonly type: {
            readonly type: "string";
          };
        };
      };
    };
    readonly description: {
      readonly type: "string";
    };
    readonly followerCount: {
      readonly type: "integer";
    };
    readonly memberCount: {
      readonly type: "integer";
    };
    readonly showCastSourceLabels: {
      readonly type: "boolean";
    };
    readonly showCastTags: {
      readonly type: "boolean";
    };
    readonly sectionRank: {
      readonly type: "integer";
    };
    readonly subscribable: {
      readonly type: "boolean";
    };
    readonly publicCasting: {
      readonly type: "boolean";
    };
    readonly inviteCode: {
      readonly type: "string";
    };
    readonly headerImageUrl: {
      readonly type: "string";
    };
    readonly headerAction: {
      readonly type: "object";
      readonly properties: {
        readonly title: {
          readonly type: "string";
        };
        readonly target: {
          readonly type: "string";
        };
      };
    };
    readonly headerActionMetadata: {
      readonly type: "object";
      readonly additionalProperties: true;
    };
    readonly viewerContext: {
      readonly type: "object";
      readonly properties: {
        readonly following: {
          readonly type: "boolean";
        };
        readonly isMember: {
          readonly type: "boolean";
        };
        readonly hasUnseenItems: {
          readonly type: "boolean";
        };
        readonly favoritePosition: {
          readonly type: "integer";
        };
        readonly activityRank: {
          readonly type: "integer";
        };
        readonly canCast: {
          readonly type: "boolean";
        };
      };
    };
  };
};
declare const HighlightedChannelsResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly channels: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/Channel";
          };
        };
        readonly viewerContext: {
          readonly type: "object";
          readonly properties: {
            readonly defaultFeed: {
              readonly type: "string";
            };
          };
        };
      };
    };
  };
};
declare const ImageEmbedSchema: {
  readonly type: "object";
  readonly properties: {
    readonly type: {
      readonly type: "string";
      readonly enum: readonly ["image"];
    };
    readonly url: {
      readonly type: "string";
    };
    readonly sourceUrl: {
      readonly type: "string";
    };
    readonly media: {
      readonly type: "object";
      readonly properties: {
        readonly version: {
          readonly type: "string";
        };
        readonly width: {
          readonly type: "integer";
        };
        readonly height: {
          readonly type: "integer";
        };
        readonly staticRaster: {
          readonly type: "string";
        };
        readonly mimeType: {
          readonly type: "string";
        };
      };
    };
    readonly alt: {
      readonly type: "string";
    };
  };
};
declare const UrlEmbedSchema: {
  readonly type: "object";
  readonly required: readonly ["type", "openGraph"];
  readonly properties: {
    readonly type: {
      readonly type: "string";
      readonly enum: readonly ["url"];
    };
    readonly openGraph: {
      readonly type: "object";
      readonly required: readonly ["url"];
      readonly properties: {
        readonly url: {
          readonly type: "string";
        };
        readonly sourceUrl: {
          readonly type: "string";
        };
        readonly title: {
          readonly type: "string";
        };
        readonly description: {
          readonly type: "string";
        };
        readonly domain: {
          readonly type: "string";
        };
        readonly image: {
          readonly type: "string";
        };
        readonly useLargeImage: {
          readonly type: "boolean";
        };
      };
    };
  };
};
declare const VideoEmbedSchema: {
  readonly type: "object";
  readonly properties: {
    readonly type: {
      readonly type: "string";
      readonly enum: readonly ["video"];
    };
  };
};
declare const RecasterSchema: {
  readonly type: "object";
  readonly properties: {
    readonly fid: {
      readonly type: "integer";
    };
    readonly username: {
      readonly type: "string";
    };
    readonly displayName: {
      readonly type: "string";
    };
    readonly recastHash: {
      readonly type: "string";
    };
  };
};
declare const CastSchema: {
  readonly type: "object";
  readonly required: readonly ["hash", "author", "text", "timestamp", "replies", "reactions", "recasts", "watches"];
  readonly properties: {
    readonly hash: {
      readonly type: "string";
      readonly description: "Unique hash identifier for the cast";
    };
    readonly threadHash: {
      readonly type: "string";
      readonly description: "Hash identifier for the thread this cast belongs to";
    };
    readonly parentHash: {
      readonly type: "string";
      readonly description: "Hash identifier of the parent cast (if this is a reply)";
    };
    readonly parentSource: {
      readonly type: "object";
      readonly properties: {
        readonly type: {
          readonly type: "string";
          readonly enum: readonly ["url"];
        };
        readonly url: {
          readonly type: "string";
        };
      };
    };
    readonly author: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly text: {
      readonly type: "string";
      readonly description: "The text content of the cast";
    };
    readonly timestamp: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Unix timestamp in milliseconds";
    };
    readonly mentions: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/User";
      };
    };
    readonly embeds: {
      readonly type: "object";
      readonly properties: {
        readonly images: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/ImageEmbed";
          };
        };
        readonly urls: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/UrlEmbed";
          };
        };
        readonly videos: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/VideoEmbed";
          };
        };
        readonly unknowns: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
          };
        };
        readonly processedCastText: {
          readonly type: "string";
        };
        readonly groupInvites: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
          };
        };
      };
    };
    readonly replies: {
      readonly type: "object";
      readonly required: readonly ["count"];
      readonly properties: {
        readonly count: {
          readonly type: "integer";
        };
      };
    };
    readonly reactions: {
      readonly type: "object";
      readonly required: readonly ["count"];
      readonly properties: {
        readonly count: {
          readonly type: "integer";
        };
      };
    };
    readonly recasts: {
      readonly type: "object";
      readonly required: readonly ["count"];
      readonly properties: {
        readonly count: {
          readonly type: "integer";
        };
        readonly recasters: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/Recaster";
          };
        };
      };
    };
    readonly watches: {
      readonly type: "object";
      readonly required: readonly ["count"];
      readonly properties: {
        readonly count: {
          readonly type: "integer";
        };
      };
    };
    readonly recast: {
      readonly type: "boolean";
    };
    readonly tags: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly properties: {
          readonly type: {
            readonly type: "string";
          };
          readonly id: {
            readonly type: "string";
          };
          readonly name: {
            readonly type: "string";
          };
          readonly imageUrl: {
            readonly type: "string";
          };
        };
      };
    };
    readonly quoteCount: {
      readonly type: "integer";
    };
    readonly combinedRecastCount: {
      readonly type: "integer";
    };
    readonly channel: {
      readonly type: "object";
      readonly properties: {
        readonly key: {
          readonly type: "string";
        };
        readonly name: {
          readonly type: "string";
        };
        readonly imageUrl: {
          readonly type: "string";
        };
        readonly authorContext: {
          readonly type: "object";
          readonly properties: {
            readonly role: {
              readonly type: "string";
            };
            readonly restricted: {
              readonly type: "boolean";
            };
            readonly banned: {
              readonly type: "boolean";
            };
          };
        };
        readonly authorRole: {
          readonly type: "string";
        };
      };
    };
    readonly viewerContext: {
      readonly type: "object";
      readonly properties: {
        readonly reacted: {
          readonly type: "boolean";
        };
        readonly recast: {
          readonly type: "boolean";
        };
        readonly bookmarked: {
          readonly type: "boolean";
        };
      };
    };
  };
};
declare const FeedItemsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["items", "replaceFeed"];
      readonly properties: {
        readonly items: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly required: readonly ["id", "timestamp", "cast"];
            readonly properties: {
              readonly id: {
                readonly type: "string";
              };
              readonly timestamp: {
                readonly type: "integer";
              };
              readonly cast: {
                readonly $ref: "#/components/schemas/Cast";
              };
              readonly otherParticipants: {
                readonly type: "array";
                readonly items: {
                  readonly $ref: "#/components/schemas/User";
                };
              };
            };
          };
        };
        readonly latestMainCastTimestamp: {
          readonly type: "integer";
        };
        readonly feedTopSeenAtTimestamp: {
          readonly type: "integer";
        };
        readonly replaceFeed: {
          readonly type: "boolean";
        };
      };
    };
  };
};
declare const GenericResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly additionalProperties: true;
    };
  };
};
declare const UserResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/GenericResponse";
  }, {
    readonly type: "object";
    readonly required: readonly ["result"];
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly properties: {
          readonly user: {
            readonly $ref: "#/components/schemas/UserWithExtras";
          };
          readonly collectionsOwned: {
            readonly type: "array";
            readonly items: {
              readonly type: "object";
            };
          };
          readonly extras: {
            readonly $ref: "#/components/schemas/UserExtras";
          };
        };
      };
    };
  }];
};
declare const PaginatedResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly additionalProperties: true;
    };
    readonly next: {
      readonly $ref: "#/components/schemas/PaginationCursor";
    };
  };
};
declare const SuggestedUsersResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/PaginatedResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly properties: {
          readonly users: {
            readonly type: "array";
            readonly items: {
              readonly type: "object";
              readonly additionalProperties: true;
            };
          };
        };
      };
    };
  }];
};
declare const FavoriteFramesResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["frames"];
      readonly properties: {
        readonly frames: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly additionalProperties: true;
          };
        };
      };
    };
  };
};
declare const ChannelStreaksResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly additionalProperties: true;
    };
  };
};
declare const UnseenCountsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly notificationsCount: {
          readonly type: "integer";
        };
        readonly notificationTabs: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly required: readonly ["tab", "unseenCount"];
            readonly properties: {
              readonly tab: {
                readonly type: "string";
              };
              readonly unseenCount: {
                readonly type: "integer";
              };
            };
          };
        };
        readonly inboxCount: {
          readonly type: "integer";
        };
        readonly channelFeeds: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly required: readonly ["channelKey", "feedType", "hasNewItems"];
            readonly properties: {
              readonly channelKey: {
                readonly type: "string";
              };
              readonly feedType: {
                readonly type: "string";
              };
              readonly hasNewItems: {
                readonly type: "boolean";
              };
            };
          };
        };
        readonly warpTransactionCount: {
          readonly type: "integer";
        };
      };
    };
  };
};
declare const UserThreadCastsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["casts"];
      readonly properties: {
        readonly casts: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly additionalProperties: true;
          };
        };
      };
    };
  };
};
declare const ChannelFollowersYouKnowResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["users", "totalCount"];
      readonly properties: {
        readonly users: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly additionalProperties: true;
          };
        };
        readonly totalCount: {
          readonly type: "integer";
        };
      };
    };
  };
};
declare const SuccessResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/GenericResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly required: readonly ["success"];
        readonly properties: {
          readonly success: {
            readonly type: "boolean";
            readonly description: "Whether the operation was successful";
          };
        };
      };
    };
  }];
};
declare const NotificationsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["notifications"];
      readonly properties: {
        readonly notifications: {
          readonly type: "array";
          readonly description: "Notification items for the requested tab.";
          readonly items: {
            readonly type: "object";
            readonly required: readonly ["id", "type", "latestTimestamp", "totalItemCount", "previewItems", "isUnread"];
            readonly properties: {
              readonly id: {
                readonly type: "string";
                readonly description: "Notification identifier.";
              };
              readonly type: {
                readonly type: "string";
                readonly description: "Notification type.";
                readonly enum: readonly ["channel-pinned-cast", "channel-role-invite", "new-cast-in-channel", "cast-mention", "cast-quote", "cast-reaction", "cast-reply", "dormant-user-new-cast", "follow", "mini-app", "new-article", "new-cast", "recast"];
              };
              readonly latestTimestamp: {
                readonly type: "integer";
                readonly format: "int64";
                readonly description: "Latest activity timestamp (ms).";
              };
              readonly totalItemCount: {
                readonly type: "integer";
                readonly description: "Number of items represented by this notification.";
              };
              readonly previewItems: {
                readonly type: "array";
                readonly description: "Sample items for this notification; structure varies by type.";
                readonly items: {
                  readonly type: "object";
                  readonly additionalProperties: true;
                };
              };
              readonly isUnread: {
                readonly type: "boolean";
                readonly description: "Whether the notification is unread.";
              };
              readonly metadata: {
                readonly type: "object";
                readonly description: "Additional notification-specific fields.";
                readonly additionalProperties: true;
              };
            };
            readonly additionalProperties: false;
          };
        };
        readonly next: {
          readonly $ref: "#/components/schemas/PaginationCursor";
        };
      };
    };
  };
};
declare const DirectCastConversationResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/GenericResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly required: readonly ["conversation"];
        readonly properties: {
          readonly conversation: {
            readonly $ref: "#/components/schemas/DirectCastConversation";
          };
        };
      };
    };
  }];
};
declare const DirectCastConversationCategorizationRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "category"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation to categorize";
      readonly example: "17838-20146";
    };
    readonly category: {
      readonly type: "string";
      readonly description: "Category to assign to the conversation";
      readonly example: "archived";
    };
  };
};
declare const DirectCastConversationMessagesResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/PaginatedResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly required: readonly ["messages"];
        readonly properties: {
          readonly messages: {
            readonly type: "array";
            readonly items: {
              readonly $ref: "#/components/schemas/DirectCastMessage";
            };
          };
        };
      };
    };
  }];
};
declare const DirectCastConversationMessageTtlRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "ttl"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation to set message TTL for";
      readonly example: "12590-20146";
    };
    readonly ttl: {
      readonly type: "integer";
      readonly description: "Time to live for messages in days";
      readonly example: 365;
    };
  };
};
declare const DirectCastConversationNotificationsRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "muted"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation to update notification settings for";
      readonly example: "17838-20146";
    };
    readonly muted: {
      readonly type: "boolean";
      readonly description: "Whether to mute notifications for this conversation";
      readonly example: false;
    };
  };
};
declare const DirectCastSendRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "recipientFids", "messageId", "type", "message"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation to send the message to";
    };
    readonly recipientFids: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
      readonly description: "Array of Farcaster IDs of message recipients";
      readonly example: readonly [17838, 861305];
    };
    readonly messageId: {
      readonly type: "string";
      readonly description: "Unique identifier for the message";
    };
    readonly type: {
      readonly type: "string";
      readonly enum: readonly ["text", "image", "reaction", "link"];
      readonly description: "Type of the message";
      readonly example: "text";
    };
    readonly message: {
      readonly type: "string";
      readonly description: "Content of the message";
    };
    readonly inReplyToId: {
      readonly type: "string";
      readonly description: "ID of the message this is replying to (optional)";
    };
  };
};
declare const DirectCastManuallyMarkUnreadRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation to mark as unread";
    };
  };
};
declare const DirectCastMessageReactionRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId", "messageId", "reaction"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation containing the message";
      readonly example: "12590-20146";
    };
    readonly messageId: {
      readonly type: "string";
      readonly description: "ID of the message to react to";
      readonly example: "17c7f0b459ff8f625fc35bba6a89c817";
    };
    readonly reaction: {
      readonly type: "string";
      readonly description: "Emoji reaction to add or remove";
      readonly example: "👍";
    };
  };
};
declare const DirectCastPinConversationRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["conversationId"];
  readonly properties: {
    readonly conversationId: {
      readonly type: "string";
      readonly description: "ID of the conversation to pin";
    };
  };
};
declare const DiscoverChannelsResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/GenericResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly properties: {
          readonly channels: {
            readonly type: "array";
            readonly items: {
              readonly type: "object";
              readonly additionalProperties: true;
            };
          };
        };
      };
    };
  }];
};
declare const InvitesAvailableResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/GenericResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly required: readonly ["allocatedInvitesCount", "availableInvitesCount"];
        readonly properties: {
          readonly allocatedInvitesCount: {
            readonly type: "integer";
            readonly description: "Total number of invites allocated to the user";
          };
          readonly availableInvitesCount: {
            readonly type: "integer";
            readonly description: "Number of invites currently available to send";
          };
        };
      };
    };
  }];
};
declare const SponsoredInvitesResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/GenericResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly properties: {
          readonly invites: {
            readonly type: "array";
            readonly items: {
              readonly type: "object";
            };
          };
        };
      };
    };
    readonly additionalProperties: true;
  }];
};
declare const RewardsLeaderboardResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["leaderboard"];
      readonly properties: {
        readonly leaderboard: {
          readonly type: "object";
          readonly required: readonly ["type", "users"];
          readonly properties: {
            readonly type: {
              readonly type: "string";
            };
            readonly users: {
              readonly type: "array";
              readonly items: {
                readonly type: "object";
                readonly properties: {
                  readonly user: {
                    readonly type: "object";
                    readonly additionalProperties: true;
                  };
                  readonly score: {
                    readonly type: "integer";
                  };
                  readonly rank: {
                    readonly type: "integer";
                  };
                };
              };
            };
          };
        };
      };
    };
  };
};
declare const RewardsScoresResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["scores"];
      readonly properties: {
        readonly scores: {
          readonly type: "array";
          readonly items: {
            readonly type: "object";
            readonly properties: {
              readonly type: {
                readonly type: "string";
              };
              readonly user: {
                readonly type: "object";
                readonly additionalProperties: true;
              };
              readonly allTimeScore: {
                readonly type: "integer";
              };
              readonly currentPeriodScore: {
                readonly type: "integer";
              };
              readonly previousPeriodScore: {
                readonly type: "integer";
              };
            };
          };
        };
      };
    };
  };
};
declare const RewardsMetadataResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly metadata: {
          readonly type: "object";
          readonly required: readonly ["type", "lastUpdateTimestamp", "currentPeriodStartTimestamp", "currentPeriodEndTimestamp"];
          readonly properties: {
            readonly type: {
              readonly type: "string";
            };
            readonly lastUpdateTimestamp: {
              readonly type: "integer";
              readonly format: "int64";
            };
            readonly currentPeriodStartTimestamp: {
              readonly type: "integer";
              readonly format: "int64";
            };
            readonly currentPeriodEndTimestamp: {
              readonly type: "integer";
              readonly format: "int64";
            };
            readonly tiers: {
              readonly type: "array";
              readonly items: {
                readonly type: "object";
                readonly additionalProperties: true;
              };
            };
            readonly proportionalPayout: {
              readonly type: "object";
              readonly properties: {
                readonly numWinners: {
                  readonly type: "integer";
                };
                readonly totalRewardCents: {
                  readonly type: "integer";
                };
              };
            };
          };
        };
      };
    };
  };
};
declare const BookmarkedCastSchema: {
  readonly type: "object";
  readonly additionalProperties: true;
};
declare const BookmarkedCastsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly bookmarks: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/BookmarkedCast";
          };
        };
      };
    };
  };
};
declare const StarterPackSchema: {
  readonly type: "object";
  readonly required: readonly ["id"];
  readonly properties: {
    readonly id: {
      readonly type: "string";
      readonly description: "Unique identifier for the starter pack";
    };
    readonly creator: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly name: {
      readonly type: "string";
      readonly description: "Display name of the starter pack";
    };
    readonly description: {
      readonly type: "string";
      readonly description: "Description of the starter pack";
    };
    readonly openGraphImageUrl: {
      readonly type: "string";
      readonly format: "uri";
      readonly description: "URL for OG image preview";
    };
    readonly itemCount: {
      readonly type: "integer";
      readonly description: "Number of items in the starter pack";
    };
    readonly items: {
      readonly type: "array";
      readonly items: {
        readonly type: "object";
        readonly additionalProperties: true;
      };
      readonly description: "Items contained in the starter pack";
    };
    readonly labels: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
      readonly description: "Labels/tags for the starter pack";
    };
  };
  readonly additionalProperties: true;
};
declare const StarterPacksResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["starterPacks"];
      readonly properties: {
        readonly starterPacks: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/StarterPack";
          };
        };
      };
    };
  };
};
declare const StarterPackResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["starterPack"];
      readonly properties: {
        readonly starterPack: {
          readonly $ref: "#/components/schemas/StarterPack";
        };
      };
    };
  };
};
declare const StarterPackUpdateRequestSchema: {
  readonly type: "object";
  readonly required: readonly ["id", "name", "description", "fids", "labels"];
  readonly properties: {
    readonly id: {
      readonly type: "string";
      readonly description: "Unique identifier for the starter pack to update";
    };
    readonly name: {
      readonly type: "string";
      readonly description: "Display name of the starter pack";
    };
    readonly description: {
      readonly type: "string";
      readonly description: "Description of the starter pack";
    };
    readonly fids: {
      readonly type: "array";
      readonly description: "List of FIDs included in the starter pack";
      readonly items: {
        readonly type: "integer";
      };
    };
    readonly labels: {
      readonly type: "array";
      readonly description: "Labels/tags for the starter pack";
      readonly items: {
        readonly type: "string";
      };
    };
  };
};
declare const StarterPackUsersResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["users"];
      readonly properties: {
        readonly users: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/User";
          };
        };
      };
    };
  };
};
declare const ChannelResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly channel: {
          readonly $ref: "#/components/schemas/Channel";
        };
      };
    };
  };
};
declare const ChannelUsersResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly users: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/User";
          };
        };
      };
    };
  };
};
declare const UsersResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["users"];
      readonly properties: {
        readonly users: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/User";
          };
        };
      };
    };
  };
};
declare const UsersWithCountResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["users", "totalCount"];
      readonly properties: {
        readonly users: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/User";
          };
        };
        readonly totalCount: {
          readonly type: "integer";
        };
      };
    };
  };
};
declare const FrameAppSchema: {
  readonly type: "object";
  readonly additionalProperties: true;
};
declare const FrameAppsResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly frames: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/FrameApp";
          };
        };
      };
    };
  };
};
declare const mini_app_ViewerContextSchema: {
  readonly type: "object";
  readonly properties: {};
  readonly description: "Context information for the viewer";
};
declare const MiniAppSchema: {
  readonly type: "object";
  readonly properties: {
    readonly domain: {
      readonly type: "string";
      readonly description: "The domain of the mini app";
    };
    readonly name: {
      readonly type: "string";
      readonly description: "The name of the mini app";
    };
    readonly iconUrl: {
      readonly type: "string";
      readonly description: "URL to the mini app's icon";
    };
    readonly homeUrl: {
      readonly type: "string";
      readonly description: "The home URL of the mini app";
    };
    readonly author: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly supportsNotifications: {
      readonly type: "boolean";
      readonly description: "Whether the mini app supports notifications";
    };
    readonly id: {
      readonly type: "string";
      readonly description: "Unique identifier for the mini app";
    };
    readonly shortId: {
      readonly type: "string";
      readonly description: "Short identifier for the mini app";
    };
    readonly imageUrl: {
      readonly type: "string";
      readonly description: "URL to the mini app's main image";
    };
    readonly buttonTitle: {
      readonly type: "string";
      readonly description: "Title for the action button";
    };
    readonly splashImageUrl: {
      readonly type: "string";
      readonly description: "URL to the splash screen image";
    };
    readonly splashBackgroundColor: {
      readonly type: "string";
      readonly description: "Background color for the splash screen";
    };
    readonly castShareUrl: {
      readonly type: "string";
      readonly description: "URL for sharing casts";
    };
    readonly subtitle: {
      readonly type: "string";
      readonly description: "Subtitle of the mini app";
    };
    readonly description: {
      readonly type: "string";
      readonly description: "Description of the mini app";
    };
    readonly tagline: {
      readonly type: "string";
      readonly description: "Tagline of the mini app";
    };
    readonly heroImageUrl: {
      readonly type: "string";
      readonly description: "URL to the hero image";
    };
    readonly primaryCategory: {
      readonly type: "string";
      readonly description: "Primary category of the mini app";
    };
    readonly tags: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
      readonly description: "Tags associated with the mini app";
    };
    readonly screenshotUrls: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
      readonly description: "URLs to screenshot images";
    };
    readonly noindex: {
      readonly type: "boolean";
      readonly description: "Whether the mini app should be indexed";
    };
    readonly ogTitle: {
      readonly type: "string";
      readonly description: "Open Graph title";
    };
    readonly ogDescription: {
      readonly type: "string";
      readonly description: "Open Graph description";
    };
    readonly ogImageUrl: {
      readonly type: "string";
      readonly description: "Open Graph image URL";
    };
    readonly requiredCapabilities: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
      readonly description: "Required capabilities for the mini app";
    };
    readonly requiredChains: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
      readonly description: "Required blockchain chains";
    };
    readonly viewerContext: {
      readonly $ref: "#/components/schemas/mini-app_ViewerContext";
    };
  };
};
declare const RankedMiniAppSchema: {
  readonly type: "object";
  readonly properties: {
    readonly rank: {
      readonly type: "integer";
      readonly description: "Current rank of the mini app";
    };
    readonly miniApp: {
      readonly $ref: "#/components/schemas/MiniApp";
    };
    readonly rank72hChange: {
      readonly type: "integer";
      readonly description: "Change in rank over the last 72 hours";
    };
  };
};
declare const TopMiniAppsResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly miniApps: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/RankedMiniApp";
          };
        };
        readonly next: {
          readonly $ref: "#/components/schemas/PaginationCursor";
        };
      };
    };
  };
};
declare const VerifiedAddressSchema: {
  readonly type: "object";
  readonly properties: {
    readonly fid: {
      readonly type: "integer";
    };
    readonly address: {
      readonly type: "string";
    };
    readonly timestamp: {
      readonly type: "integer";
    };
    readonly version: {
      readonly type: "string";
    };
    readonly protocol: {
      readonly type: "string";
    };
    readonly isPrimary: {
      readonly type: "boolean";
    };
    readonly labels: {
      readonly type: "array";
      readonly items: {
        readonly type: "string";
      };
    };
  };
};
declare const MutedKeywordPropertiesSchema: {
  readonly type: "object";
  readonly properties: {
    readonly channels: {
      readonly type: "boolean";
    };
    readonly frames: {
      readonly type: "boolean";
    };
    readonly notifications: {
      readonly type: "boolean";
    };
  };
};
declare const MutedKeywordSchema: {
  readonly type: "object";
  readonly required: readonly ["keyword", "properties"];
  readonly properties: {
    readonly keyword: {
      readonly type: "string";
    };
    readonly properties: {
      readonly $ref: "#/components/schemas/MutedKeywordProperties";
    };
  };
};
declare const MutedKeywordsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["success", "result"];
  readonly properties: {
    readonly success: {
      readonly type: "boolean";
    };
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["keywords", "mutedKeywords"];
      readonly properties: {
        readonly keywords: {
          readonly type: "array";
          readonly items: {
            readonly type: "string";
          };
        };
        readonly mutedKeywords: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/MutedKeyword";
          };
        };
      };
    };
  };
};
declare const CastHashResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly castHash: {
          readonly type: "string";
          readonly example: "0x750a7269b4a3b70e28d3f450df33487047d4927f";
        };
      };
    };
  };
};
declare const AttachEmbedsResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly additionalProperties: true;
    };
  };
};
declare const CastRecastersResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly users: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/User";
          };
        };
      };
    };
  };
};
declare const CastQuoteSchema: {
  readonly type: "object";
  readonly properties: {
    readonly hash: {
      readonly type: "string";
    };
    readonly threadHash: {
      readonly type: "string";
    };
    readonly parentSource: {
      readonly type: "object";
      readonly properties: {
        readonly type: {
          readonly type: "string";
        };
        readonly url: {
          readonly type: "string";
        };
      };
    };
    readonly author: {
      readonly $ref: "#/components/schemas/User";
    };
    readonly text: {
      readonly type: "string";
    };
    readonly timestamp: {
      readonly type: "integer";
    };
  };
};
declare const CastQuotesResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly quotes: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/CastQuote";
          };
        };
      };
    };
  };
};
declare const user_response_UserResponseSchema: {
  readonly type: "object";
  readonly required: readonly ["result"];
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly required: readonly ["user"];
      readonly properties: {
        readonly user: {
          readonly $ref: "#/components/schemas/User";
        };
      };
    };
  };
};
declare const SearchChannelsResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly channels: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/Channel";
          };
        };
      };
    };
  };
};
declare const DraftsResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly drafts: {
          readonly type: "array";
          readonly items: {};
        };
      };
    };
  };
};
declare const DraftCastSchema: {
  readonly type: "object";
  readonly properties: {
    readonly text: {
      readonly type: "string";
    };
    readonly embeds: {
      readonly type: "array";
      readonly items: {};
    };
  };
};
declare const DraftSchema: {
  readonly type: "object";
  readonly properties: {
    readonly draftId: {
      readonly type: "string";
    };
    readonly casts: {
      readonly type: "array";
      readonly items: {
        readonly $ref: "#/components/schemas/DraftCast";
      };
    };
  };
};
declare const DraftCreatedResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly draft: {
          readonly $ref: "#/components/schemas/Draft";
        };
      };
    };
  };
};
declare const CastCreatedResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly cast: {
          readonly $ref: "#/components/schemas/Cast";
        };
      };
    };
  };
};
declare const RawChannelSchema: {
  readonly type: "object";
  readonly properties: {
    readonly id: {
      readonly type: "string";
    };
    readonly url: {
      readonly type: "string";
    };
    readonly name: {
      readonly type: "string";
    };
    readonly description: {
      readonly type: "string";
    };
    readonly descriptionMentions: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
    };
    readonly descriptionMentionsPositions: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
    };
    readonly imageUrl: {
      readonly type: "string";
    };
    readonly headerImageUrl: {
      readonly type: "string";
    };
    readonly leadFid: {
      readonly type: "integer";
    };
    readonly moderatorFids: {
      readonly type: "array";
      readonly items: {
        readonly type: "integer";
      };
    };
    readonly createdAt: {
      readonly type: "integer";
    };
    readonly followerCount: {
      readonly type: "integer";
    };
    readonly memberCount: {
      readonly type: "integer";
    };
    readonly pinnedCastHash: {
      readonly type: "string";
    };
    readonly publicCasting: {
      readonly type: "boolean";
    };
    readonly externalLink: {
      readonly type: "object";
      readonly properties: {
        readonly title: {
          readonly type: "string";
        };
        readonly url: {
          readonly type: "string";
        };
      };
    };
  };
};
declare const ChannelListResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly channels: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/RawChannel";
          };
        };
      };
    };
  };
};
declare const RawChannelResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly channel: {
          readonly $ref: "#/components/schemas/RawChannel";
        };
      };
    };
  };
};
declare const ChannelFollowerSchema: {
  readonly type: "object";
  readonly properties: {
    readonly fid: {
      readonly type: "integer";
    };
    readonly followedAt: {
      readonly type: "integer";
    };
  };
};
declare const ChannelFollowersResponseSchema: {
  readonly allOf: readonly [{
    readonly $ref: "#/components/schemas/PaginatedResponse";
  }, {
    readonly type: "object";
    readonly properties: {
      readonly result: {
        readonly type: "object";
        readonly properties: {
          readonly users: {
            readonly type: "array";
            readonly items: {
              readonly $ref: "#/components/schemas/ChannelFollower";
            };
          };
        };
      };
    };
  }];
};
declare const ChannelFollowStatusSchema: {
  readonly type: "object";
  readonly properties: {
    readonly following: {
      readonly type: "boolean";
    };
    readonly followedAt: {
      readonly type: "integer";
    };
  };
};
declare const ChannelFollowStatusResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly $ref: "#/components/schemas/ChannelFollowStatus";
    };
  };
};
declare const ActionSchema: {
  readonly type: "object";
  readonly properties: {
    readonly name: {
      readonly type: "string";
    };
    readonly icon: {
      readonly type: "string";
    };
    readonly description: {
      readonly type: "string";
    };
    readonly aboutUrl: {
      readonly type: "string";
      readonly format: "uri";
    };
    readonly imageUrl: {
      readonly type: "string";
      readonly format: "uri";
    };
    readonly actionUrl: {
      readonly type: "string";
      readonly format: "uri";
    };
    readonly action: {
      readonly type: "object";
      readonly properties: {
        readonly actionType: {
          readonly type: "string";
          readonly enum: readonly ["post", "get", "put", "delete"];
        };
        readonly postUrl: {
          readonly type: "string";
          readonly format: "uri";
        };
      };
    };
  };
};
declare const WinnerSchema: {
  readonly type: "object";
  readonly properties: {
    readonly fid: {
      readonly type: "integer";
      readonly description: "The fid of the winner";
    };
    readonly domain: {
      readonly type: "string";
      readonly description: "The domain of the winner";
    };
    readonly frameName: {
      readonly type: "string";
      readonly description: "The name of the frame (mini app)";
    };
    readonly score: {
      readonly type: "integer";
      readonly description: "The score of the winner";
    };
    readonly rank: {
      readonly type: "integer";
      readonly description: "The rank of the winner";
    };
    readonly rewardCents: {
      readonly type: "integer";
      readonly description: "The reward amount in cents";
    };
    readonly walletAddress: {
      readonly type: "string";
      readonly description: "The wallet address of the winner (optional)";
    };
  };
};
declare const FrameSchema: {
  readonly type: "object";
  readonly properties: {
    readonly domain: {
      readonly type: "string";
    };
    readonly name: {
      readonly type: "string";
    };
    readonly iconUrl: {
      readonly type: "string";
    };
    readonly homeUrl: {
      readonly type: "string";
    };
    readonly splashImageUrl: {
      readonly type: "string";
    };
    readonly splashBackgroundColor: {
      readonly type: "string";
    };
    readonly buttonTitle: {
      readonly type: readonly ["string", "null"];
    };
    readonly imageUrl: {
      readonly type: readonly ["string", "null"];
    };
    readonly supportsNotifications: {
      readonly type: "boolean";
    };
    readonly viewerContext: {
      readonly type: "object";
      readonly additionalProperties: true;
    };
    readonly author: {
      readonly $ref: "#/components/schemas/User";
    };
  };
};
declare const AppsByAuthorResponseSchema: {
  readonly type: "object";
  readonly properties: {
    readonly result: {
      readonly type: "object";
      readonly properties: {
        readonly frames: {
          readonly type: "array";
          readonly items: {
            readonly $ref: "#/components/schemas/Frame";
          };
        };
      };
    };
  };
};
declare const ApiKeySchema: {
  readonly type: "object";
  readonly required: readonly ["id", "createdAt", "expiresAt", "tag", "description"];
  readonly properties: {
    readonly id: {
      readonly type: "string";
      readonly format: "uuid";
      readonly description: "Unique identifier for the API key";
    };
    readonly createdAt: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Timestamp when the API key was created (in milliseconds since epoch)";
    };
    readonly expiresAt: {
      readonly type: "integer";
      readonly format: "int64";
      readonly description: "Timestamp when the API key expires (in milliseconds since epoch)";
    };
    readonly revokedAt: {
      readonly type: readonly ["string", "null"];
      readonly format: "int64";
      readonly description: "Timestamp when the API key was revoked, if applicable (in milliseconds since epoch)";
    };
    readonly tag: {
      readonly type: "string";
      readonly description: "Short identifier tag for the API key";
    };
    readonly description: {
      readonly type: "string";
      readonly description: "User-provided description of the API key's purpose";
    };
  };
};
declare const DirectCastSendResponseSchema: {
  readonly $ref: "#/components/schemas/SuccessResponse";
};
declare const DirectCastConversationCategorizationResponseSchema: {
  readonly $ref: "#/components/schemas/SuccessResponse";
};
declare const DirectCastConversationNotificationsResponseSchema: {
  readonly $ref: "#/components/schemas/SuccessResponse";
};
declare const DirectCastConversationMessageTtlResponseSchema: {
  readonly $ref: "#/components/schemas/SuccessResponse";
};
declare const DirectCastMessageReactionResponseSchema: {
  readonly $ref: "#/components/schemas/SuccessResponse";
};
//#endregion
//#region package.d.ts
declare let version: string;
//#endregion
//#region src/client/sdk.gen.d.ts
type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options<TData, ThrowOnError> & {
  /**
   * You can provide a client instance returned by `createClient()` instead of
   * individual options. This might be also useful if you want to implement a
   * custom client.
   */
  client?: Client;
  /**
   * You can pass arbitrary values through the `meta` object. This can be
   * used to access values that aren't defined as part of the SDK function.
   */
  meta?: Record<string, unknown>;
};
/**
 * Get onboarding state
 *
 * Retrieves the current onboarding state for the authenticated user
 */
declare const getUserOnboardingState: <ThrowOnError extends boolean = false>(options?: Options$1<GetUserOnboardingStateData, ThrowOnError>) => RequestResult<GetUserOnboardingStateResponses, GetUserOnboardingStateErrors, ThrowOnError, "fields">;
/**
 * Get user by fid
 *
 * Retrieves user information based on FID
 */
declare const getUserByFid: <ThrowOnError extends boolean = false>(options: Options$1<GetUserByFidData, ThrowOnError>) => RequestResult<GetUserByFidResponses, GetUserByFidErrors, ThrowOnError, "fields">;
/**
 * Get user's direct cast inbox
 *
 * Retrieves direct casts sent to the authenticated user
 */
declare const getDirectCastInbox: <ThrowOnError extends boolean = false>(options?: Options$1<GetDirectCastInboxData, ThrowOnError>) => RequestResult<GetDirectCastInboxResponses, GetDirectCastInboxErrors, ThrowOnError, "fields">;
/**
 * Get user app context
 *
 * Retrieves application context information for the authenticated user
 */
declare const getUserAppContext: <ThrowOnError extends boolean = false>(options?: Options$1<GetUserAppContextData, ThrowOnError>) => RequestResult<GetUserAppContextResponses, GetUserAppContextErrors, ThrowOnError, "fields">;
/**
 * Get user preferences
 *
 * Retrieves preference settings for the authenticated user
 */
declare const getUserPreferences: <ThrowOnError extends boolean = false>(options?: Options$1<GetUserPreferencesData, ThrowOnError>) => RequestResult<GetUserPreferencesResponses, GetUserPreferencesErrors, ThrowOnError, "fields">;
/**
 * Get highlighted channels
 *
 * Retrieves a list of featured or recommended channels
 */
declare const getHighlightedChannels: <ThrowOnError extends boolean = false>(options?: Options$1<GetHighlightedChannelsData, ThrowOnError>) => RequestResult<GetHighlightedChannelsResponses, GetHighlightedChannelsErrors, ThrowOnError, "fields">;
/**
 * Get feed items
 *
 * Retrieves feed content based on provided filters and parameters
 */
declare const getFeedItems: <ThrowOnError extends boolean = false>(options: Options$1<GetFeedItemsData, ThrowOnError>) => RequestResult<GetFeedItemsResponses, GetFeedItemsErrors, ThrowOnError, "fields">;
/**
 * Get user information
 *
 * Retrieves detailed user information based on FID
 */
declare const getUser: <ThrowOnError extends boolean = false>(options: Options$1<GetUserData, ThrowOnError>) => RequestResult<GetUserResponses, GetUserErrors, ThrowOnError, "fields">;
/**
 * Get user following channels
 *
 * Retrieves channels that the authenticated user is following
 */
declare const getUserFollowingChannels: <ThrowOnError extends boolean = false>(options?: Options$1<GetUserFollowingChannelsData, ThrowOnError>) => RequestResult<GetUserFollowingChannelsResponses, GetUserFollowingChannelsErrors, ThrowOnError, "fields">;
/**
 * Get suggested users
 */
declare const getSuggestedUsers: <ThrowOnError extends boolean = false>(options?: Options$1<GetSuggestedUsersData, ThrowOnError>) => RequestResult<GetSuggestedUsersResponses, GetSuggestedUsersErrors, ThrowOnError, "fields">;
/**
 * Get user's favorite frames
 */
declare const getUserFavoriteFrames: <ThrowOnError extends boolean = false>(options?: Options$1<GetUserFavoriteFramesData, ThrowOnError>) => RequestResult<GetUserFavoriteFramesResponses, GetUserFavoriteFramesErrors, ThrowOnError, "fields">;
/**
 * Get user by username
 *
 * Retrieves user information based on username
 */
declare const getUserByUsername: <ThrowOnError extends boolean = false>(options: Options$1<GetUserByUsernameData, ThrowOnError>) => RequestResult<GetUserByUsernameResponses, GetUserByUsernameErrors, ThrowOnError, "fields">;
/**
 * Get channel streaks for user
 */
declare const getChannelStreaksForUser: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelStreaksForUserData, ThrowOnError>) => RequestResult<GetChannelStreaksForUserResponses, GetChannelStreaksForUserErrors, ThrowOnError, "fields">;
/**
 * Get unseen counts and feed state
 */
declare const getUnseenCounts: <ThrowOnError extends boolean = false>(options?: Options$1<GetUnseenCountsData, ThrowOnError>) => RequestResult<GetUnseenCountsResponses, GetUnseenCountsErrors, ThrowOnError, "fields">;
/**
 * Get casts from a user thread
 *
 * Retrieves casts from a specific thread by a user
 */
declare const getUserThreadCasts: <ThrowOnError extends boolean = false>(options: Options$1<GetUserThreadCastsData, ThrowOnError>) => RequestResult<GetUserThreadCastsResponses, GetUserThreadCastsErrors, ThrowOnError, "fields">;
/**
 * Get mutual followers in a channel
 */
declare const getChannelFollowersYouKnow: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelFollowersYouKnowData, ThrowOnError>) => RequestResult<GetChannelFollowersYouKnowResponses, GetChannelFollowersYouKnowErrors, ThrowOnError, "fields">;
/**
 * Mark all notifications as read
 */
declare const markAllNotificationsRead: <ThrowOnError extends boolean = false>(options: Options$1<MarkAllNotificationsReadData, ThrowOnError>) => RequestResult<MarkAllNotificationsReadResponses, MarkAllNotificationsReadErrors, ThrowOnError, "fields">;
/**
 * Get notifications for a specific tab
 *
 * Returns a list of notifications for the specified tab.
 */
declare const getNotifications: <ThrowOnError extends boolean = false>(options: Options$1<GetNotificationsData, ThrowOnError>) => RequestResult<GetNotificationsResponses, GetNotificationsErrors, ThrowOnError, "fields">;
/**
 * Set last checked timestamp
 *
 * Updates the last checked timestamp for notifications.
 */
declare const setLastCheckedTimestamp: <ThrowOnError extends boolean = false>(options: Options$1<SetLastCheckedTimestampData, ThrowOnError>) => RequestResult<SetLastCheckedTimestampResponses, SetLastCheckedTimestampErrors, ThrowOnError, "fields">;
/**
 * Get direct cast conversation
 *
 * Fetches a direct cast conversation by conversationId.
 */
declare const getDirectCastConversation: <ThrowOnError extends boolean = false>(options: Options$1<GetDirectCastConversationData, ThrowOnError>) => RequestResult<GetDirectCastConversationResponses, GetDirectCastConversationErrors, ThrowOnError, "fields">;
/**
 * Categorize direct cast conversation
 *
 * Categorizes a direct cast conversation by setting its category (e.g., archived).
 */
declare const categorizeDirectCastConversation: <ThrowOnError extends boolean = false>(options: Options$1<CategorizeDirectCastConversationData, ThrowOnError>) => RequestResult<CategorizeDirectCastConversationResponses, CategorizeDirectCastConversationErrors, ThrowOnError, "fields">;
/**
 * Get direct cast conversation messages
 *
 * Fetches messages from a direct cast conversation by conversationId with pagination support.
 */
declare const getDirectCastConversationMessages: <ThrowOnError extends boolean = false>(options: Options$1<GetDirectCastConversationMessagesData, ThrowOnError>) => RequestResult<GetDirectCastConversationMessagesResponses, GetDirectCastConversationMessagesErrors, ThrowOnError, "fields">;
/**
 * Set direct cast conversation message TTL
 *
 * Sets the time-to-live (TTL) for messages in a direct cast conversation.
 */
declare const setDirectCastConversationMessageTtl: <ThrowOnError extends boolean = false>(options: Options$1<SetDirectCastConversationMessageTtlData, ThrowOnError>) => RequestResult<SetDirectCastConversationMessageTtlResponses, SetDirectCastConversationMessageTtlErrors, ThrowOnError, "fields">;
/**
 * Update direct cast conversation notifications
 *
 * Updates notification settings for a direct cast conversation.
 */
declare const updateDirectCastConversationNotifications: <ThrowOnError extends boolean = false>(options: Options$1<UpdateDirectCastConversationNotificationsData, ThrowOnError>) => RequestResult<UpdateDirectCastConversationNotificationsResponses, UpdateDirectCastConversationNotificationsErrors, ThrowOnError, "fields">;
/**
 * Get recent messages from direct cast conversation
 *
 * Fetches recent messages from a direct cast conversation by conversationId.
 */
declare const getDirectCastConversationRecentMessages: <ThrowOnError extends boolean = false>(options: Options$1<GetDirectCastConversationRecentMessagesData, ThrowOnError>) => RequestResult<GetDirectCastConversationRecentMessagesResponses, GetDirectCastConversationRecentMessagesErrors, ThrowOnError, "fields">;
/**
 * Send direct cast message
 *
 * Sends a direct cast message to specified recipients in a conversation.
 */
declare const sendDirectCastMessage: <ThrowOnError extends boolean = false>(options: Options$1<SendDirectCastMessageData, ThrowOnError>) => RequestResult<SendDirectCastMessageResponses, SendDirectCastMessageErrors, ThrowOnError, "fields">;
/**
 * Manually mark direct cast conversation as unread
 *
 * Marks a direct cast conversation as unread for the authenticated user.
 */
declare const directCastManuallyMarkUnread: <ThrowOnError extends boolean = false>(options: Options$1<DirectCastManuallyMarkUnreadData, ThrowOnError>) => RequestResult<DirectCastManuallyMarkUnreadResponses, DirectCastManuallyMarkUnreadErrors, ThrowOnError, "fields">;
/**
 * Remove reaction from direct cast message
 *
 * Removes an emoji reaction from a specific message in a direct cast conversation.
 */
declare const removeDirectCastMessageReaction: <ThrowOnError extends boolean = false>(options: Options$1<RemoveDirectCastMessageReactionData, ThrowOnError>) => RequestResult<RemoveDirectCastMessageReactionResponses, RemoveDirectCastMessageReactionErrors, ThrowOnError, "fields">;
/**
 * Add reaction to direct cast message
 *
 * Adds an emoji reaction to a specific message in a direct cast conversation.
 */
declare const addDirectCastMessageReaction: <ThrowOnError extends boolean = false>(options: Options$1<AddDirectCastMessageReactionData, ThrowOnError>) => RequestResult<AddDirectCastMessageReactionResponses, AddDirectCastMessageReactionErrors, ThrowOnError, "fields">;
/**
 * Unpin direct cast conversation
 *
 * Unpins a direct cast conversation by conversationId.
 */
declare const unpinDirectCastConversation: <ThrowOnError extends boolean = false>(options: Options$1<UnpinDirectCastConversationData, ThrowOnError>) => RequestResult<UnpinDirectCastConversationResponses, UnpinDirectCastConversationErrors, ThrowOnError, "fields">;
/**
 * Pin direct cast conversation
 *
 * Pins a direct cast conversation by conversationId.
 */
declare const pinDirectCastConversation: <ThrowOnError extends boolean = false>(options: Options$1<PinDirectCastConversationData, ThrowOnError>) => RequestResult<PinDirectCastConversationResponses, PinDirectCastConversationErrors, ThrowOnError, "fields">;
/**
 * Discover channels
 *
 * Retrieves a list of discoverable channels with optional limit.
 */
declare const discoverChannels: <ThrowOnError extends boolean = false>(options?: Options$1<DiscoverChannelsData, ThrowOnError>) => RequestResult<DiscoverChannelsResponses, DiscoverChannelsErrors, ThrowOnError, "fields">;
/**
 * Check available invites
 *
 * Returns the number of allocated and currently available invites.
 */
declare const getAvailableInvites: <ThrowOnError extends boolean = false>(options?: Options$1<GetAvailableInvitesData, ThrowOnError>) => RequestResult<GetAvailableInvitesResponses, GetAvailableInvitesErrors, ThrowOnError, "fields">;
/**
 * Get sponsored invites
 *
 * Returns a list of Warpcast-sponsored invites available to the user.
 */
declare const getSponsoredInvites: <ThrowOnError extends boolean = false>(options?: Options$1<GetSponsoredInvitesData, ThrowOnError>) => RequestResult<GetSponsoredInvitesResponses, GetSponsoredInvitesErrors, ThrowOnError, "fields">;
/**
 * Get or create referral code
 *
 * Gets an existing referral code or creates a new one for the authenticated user.
 */
declare const getOrCreateReferralCode: <ThrowOnError extends boolean = false>(options: Options$1<GetOrCreateReferralCodeData, ThrowOnError>) => RequestResult<GetOrCreateReferralCodeResponses, GetOrCreateReferralCodeErrors, ThrowOnError, "fields">;
/**
 * Get rewards leaderboard
 *
 * Returns a list of users in the rewards leaderboard based on invite activity.
 */
declare const getRewardsLeaderboard: <ThrowOnError extends boolean = false>(options: Options$1<GetRewardsLeaderboardData, ThrowOnError>) => RequestResult<GetRewardsLeaderboardResponses, GetRewardsLeaderboardErrors, ThrowOnError, "fields">;
/**
 * Get invite rewards scores for a user
 *
 * Returns current, previous, and all-time invite rewards scores for the specified user.
 */
declare const getUserRewardsScores: <ThrowOnError extends boolean = false>(options: Options$1<GetUserRewardsScoresData, ThrowOnError>) => RequestResult<GetUserRewardsScoresResponses, GetUserRewardsScoresErrors, ThrowOnError, "fields">;
/**
 * Get invite rewards metadata
 *
 * Returns metadata for the invite rewards program including the reward period and reward distribution details.
 */
declare const getRewardsMetadata: <ThrowOnError extends boolean = false>(options: Options$1<GetRewardsMetadataData, ThrowOnError>) => RequestResult<GetRewardsMetadataResponses, GetRewardsMetadataErrors, ThrowOnError, "fields">;
/**
 * Get XP rewards
 *
 * Retrieves the user's XP rewards, including total USDC earned and referral count.
 */
declare const getXpRewards: <ThrowOnError extends boolean = false>(options?: Options$1<GetXpRewardsData, ThrowOnError>) => RequestResult<GetXpRewardsResponses, GetXpRewardsErrors, ThrowOnError, "fields">;
/**
 * Get XP claimable summary
 *
 * Retrieves a summary of claimable XP rewards for the authenticated user.
 */
declare const getXpClaimableSummary: <ThrowOnError extends boolean = false>(options: Options$1<GetXpClaimableSummaryData, ThrowOnError>) => RequestResult<GetXpClaimableSummaryResponses, GetXpClaimableSummaryErrors, ThrowOnError, "fields">;
/**
 * Get bookmarked casts
 *
 * Returns the most recent casts bookmarked by the user.
 */
declare const getBookmarkedCasts: <ThrowOnError extends boolean = false>(options?: Options$1<GetBookmarkedCastsData, ThrowOnError>) => RequestResult<GetBookmarkedCastsResponses, GetBookmarkedCastsErrors, ThrowOnError, "fields">;
/**
 * Get starter packs
 *
 * Returns starter packs created by a specific user.
 */
declare const getUserStarterPacks: <ThrowOnError extends boolean = false>(options: Options$1<GetUserStarterPacksData, ThrowOnError>) => RequestResult<GetUserStarterPacksResponses, GetUserStarterPacksErrors, ThrowOnError, "fields">;
/**
 * Get suggested starter packs
 *
 * Returns a list of suggested starter packs.
 */
declare const getSuggestedStarterPacks: <ThrowOnError extends boolean = false>(options?: Options$1<GetSuggestedStarterPacksData, ThrowOnError>) => RequestResult<GetSuggestedStarterPacksResponses, GetSuggestedStarterPacksErrors, ThrowOnError, "fields">;
/**
 * Get a specific starter pack by ID
 *
 * Returns a specific starter pack.
 */
declare const getStarterPack: <ThrowOnError extends boolean = false>(options: Options$1<GetStarterPackData, ThrowOnError>) => RequestResult<GetStarterPackResponses, GetStarterPackErrors, ThrowOnError, "fields">;
/**
 * Update a starter pack
 *
 * Updates the specified starter pack.
 */
declare const updateStarterPack: <ThrowOnError extends boolean = false>(options: Options$1<UpdateStarterPackData, ThrowOnError>) => RequestResult<UpdateStarterPackResponses, UpdateStarterPackErrors, ThrowOnError, "fields">;
/**
 * Get users in a specific starter pack
 *
 * Returns a list of users associated with a given starter pack.
 */
declare const getStarterPackUsers: <ThrowOnError extends boolean = false>(options: Options$1<GetStarterPackUsersData, ThrowOnError>) => RequestResult<GetStarterPackUsersResponses, GetStarterPackUsersErrors, ThrowOnError, "fields">;
/**
 * Get channel details
 *
 * Returns metadata about a channel.
 */
declare const getChannel: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelData, ThrowOnError>) => RequestResult<GetChannelResponses, GetChannelErrors, ThrowOnError, "fields">;
/**
 * Get members of a specific channel
 *
 * Returns users who are members of a specific channel.
 */
declare const getChannelUsers: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelUsersData, ThrowOnError>) => RequestResult<GetChannelUsersResponses, GetChannelUsersErrors, ThrowOnError, "fields">;
/**
 * Get users a given user is following
 *
 * Returns a list of users followed by a specified FID.
 */
declare const getFollowing: <ThrowOnError extends boolean = false>(options: Options$1<GetFollowingData, ThrowOnError>) => RequestResult<GetFollowingResponses, GetFollowingErrors, ThrowOnError, "fields">;
/**
 * Get users following a given user
 *
 * Returns a list of users who follow the specified FID.
 */
declare const getFollowers: <ThrowOnError extends boolean = false>(options: Options$1<GetFollowersData, ThrowOnError>) => RequestResult<GetFollowersResponses, GetFollowersErrors, ThrowOnError, "fields">;
/**
 * Get mutual followers of a given user
 *
 * Returns a list of users who follow the given FID and are followed by the viewer.
 */
declare const getMutualFollowers: <ThrowOnError extends boolean = false>(options: Options$1<GetMutualFollowersData, ThrowOnError>) => RequestResult<GetMutualFollowersResponses, GetMutualFollowersErrors, ThrowOnError, "fields">;
/**
 * Get top FrameApps
 *
 * Returns a list of top FrameApps with optional pagination.
 */
declare const getTopFrameApps: <ThrowOnError extends boolean = false>(options?: Options$1<GetTopFrameAppsData, ThrowOnError>) => RequestResult<GetTopFrameAppsResponses, GetTopFrameAppsErrors, ThrowOnError, "fields">;
/**
 * Get top mini apps
 *
 * Returns a list of top mini apps with optional pagination.
 */
declare const getTopMiniApps: <ThrowOnError extends boolean = false>(options?: Options$1<GetTopMiniAppsData, ThrowOnError>) => RequestResult<GetTopMiniAppsResponses, GetTopMiniAppsErrors, ThrowOnError, "fields">;
/**
 * Get verified addresses for an FID
 *
 * Returns verified Ethereum addresses associated with a specific FID.
 */
declare const getVerifications: <ThrowOnError extends boolean = false>(options: Options$1<GetVerificationsData, ThrowOnError>) => RequestResult<GetVerificationsResponses, GetVerificationsErrors, ThrowOnError, "fields">;
/**
 * Get muted keywords
 *
 * Returns a list of muted keywords for the authenticated user.
 */
declare const getMutedKeywords: <ThrowOnError extends boolean = false>(options?: Options$1<GetMutedKeywordsData, ThrowOnError>) => RequestResult<GetMutedKeywordsResponses, GetMutedKeywordsErrors, ThrowOnError, "fields">;
/**
 * Mute a keyword
 *
 * Mutes a keyword for the authenticated user with specified properties.
 */
declare const muteKeyword: <ThrowOnError extends boolean = false>(options: Options$1<MuteKeywordData, ThrowOnError>) => RequestResult<MuteKeywordResponses, MuteKeywordErrors, ThrowOnError, "fields">;
/**
 * Unmute a keyword
 */
declare const unmuteKeyword: <ThrowOnError extends boolean = false>(options: Options$1<UnmuteKeywordData, ThrowOnError>) => RequestResult<UnmuteKeywordResponses, UnmuteKeywordErrors, ThrowOnError, "fields">;
/**
 * Unlike a cast
 */
declare const unlikeCast: <ThrowOnError extends boolean = false>(options: Options$1<UnlikeCastData, ThrowOnError>) => RequestResult<UnlikeCastResponses, UnlikeCastErrors, ThrowOnError, "fields">;
/**
 * Get cast likes
 */
declare const getCastLikes: <ThrowOnError extends boolean = false>(options: Options$1<GetCastLikesData, ThrowOnError>) => RequestResult<GetCastLikesResponses, GetCastLikesErrors, ThrowOnError, "fields">;
/**
 * Like a cast
 */
declare const likeCast: <ThrowOnError extends boolean = false>(options: Options$1<LikeCastData, ThrowOnError>) => RequestResult<LikeCastResponses, LikeCastErrors, ThrowOnError, "fields">;
/**
 * Undo recast
 */
declare const undoRecast: <ThrowOnError extends boolean = false>(options: Options$1<UndoRecastData, ThrowOnError>) => RequestResult<UndoRecastResponses, UndoRecastErrors, ThrowOnError, "fields">;
/**
 * Recast a cast
 */
declare const recastCast: <ThrowOnError extends boolean = false>(options: Options$1<RecastCastData, ThrowOnError>) => RequestResult<RecastCastResponses, RecastCastErrors, ThrowOnError, "fields">;
/**
 * Attach embeds to a cast
 */
declare const attachEmbeds: <ThrowOnError extends boolean = false>(options: Options$1<AttachEmbedsData, ThrowOnError>) => RequestResult<AttachEmbedsResponses, AttachEmbedsErrors, ThrowOnError, "fields">;
/**
 * Get cast recasters
 */
declare const getCastRecasters: <ThrowOnError extends boolean = false>(options: Options$1<GetCastRecastersData, ThrowOnError>) => RequestResult<GetCastRecastersResponses, GetCastRecastersErrors, ThrowOnError, "fields">;
/**
 * Get quotes of a cast
 */
declare const getCastQuotes: <ThrowOnError extends boolean = false>(options: Options$1<GetCastQuotesData, ThrowOnError>) => RequestResult<GetCastQuotesResponses, GetCastQuotesErrors, ThrowOnError, "fields">;
/**
 * Get current user
 */
declare const getCurrentUser: <ThrowOnError extends boolean = false>(options?: Options$1<GetCurrentUserData, ThrowOnError>) => RequestResult<GetCurrentUserResponses, GetCurrentUserErrors, ThrowOnError, "fields">;
/**
 * Search for channels
 */
declare const searchChannels: <ThrowOnError extends boolean = false>(options?: Options$1<SearchChannelsData, ThrowOnError>) => RequestResult<SearchChannelsResponses, SearchChannelsErrors, ThrowOnError, "fields">;
/**
 * Get draft cast storms
 */
declare const getDraftCasts: <ThrowOnError extends boolean = false>(options?: Options$1<GetDraftCastsData, ThrowOnError>) => RequestResult<GetDraftCastsResponses, GetDraftCastsErrors, ThrowOnError, "fields">;
/**
 * Create a new draft casts
 */
declare const createDraftCasts: <ThrowOnError extends boolean = false>(options: Options$1<CreateDraftCastsData, ThrowOnError>) => RequestResult<CreateDraftCastsResponses, CreateDraftCastsErrors, ThrowOnError, "fields">;
/**
 * Delete a draft cast
 */
declare const deleteDraftCast: <ThrowOnError extends boolean = false>(options: Options$1<DeleteDraftCastData, ThrowOnError>) => RequestResult<DeleteDraftCastResponses, DeleteDraftCastErrors, ThrowOnError, "fields">;
/**
 * Delete a cast
 */
declare const deleteCast: <ThrowOnError extends boolean = false>(options: Options$1<DeleteCastData, ThrowOnError>) => RequestResult<DeleteCastResponses, DeleteCastErrors, ThrowOnError, "fields">;
/**
 * Retrieve casts for a specific user
 */
declare const getCastsByFid: <ThrowOnError extends boolean = false>(options: Options$1<GetCastsByFidData, ThrowOnError>) => RequestResult<GetCastsByFidResponses, GetCastsByFidErrors, ThrowOnError, "fields">;
/**
 * Create a new cast
 */
declare const createCast: <ThrowOnError extends boolean = false>(options: Options$1<CreateCastData, ThrowOnError>) => RequestResult<CreateCastResponses, CreateCastErrors, ThrowOnError, "fields">;
/**
 * Get all channels
 *
 * Returns a list of all channels on Warpcast
 */
declare const getAllChannels: <ThrowOnError extends boolean = false>(options?: Options$1<GetAllChannelsData, ThrowOnError>) => RequestResult<GetAllChannelsResponses, GetAllChannelsErrors, ThrowOnError, "fields">;
/**
 * Get details of a specific channel
 */
declare const getChannelDetails: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelDetailsData, ThrowOnError>) => RequestResult<GetChannelDetailsResponses, GetChannelDetailsErrors, ThrowOnError, "fields">;
/**
 * Get followers of a channel
 */
declare const getChannelFollowers: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelFollowersData, ThrowOnError>) => RequestResult<GetChannelFollowersResponses, GetChannelFollowersErrors, ThrowOnError, "fields">;
/**
 * Get list of channels followed by a user
 */
declare const getUserFollowedChannels: <ThrowOnError extends boolean = false>(options: Options$1<GetUserFollowedChannelsData, ThrowOnError>) => RequestResult<GetUserFollowedChannelsResponses, GetUserFollowedChannelsErrors, ThrowOnError, "fields">;
/**
 * Check if a user is following a channel
 */
declare const checkUserChannelFollowStatus: <ThrowOnError extends boolean = false>(options: Options$1<CheckUserChannelFollowStatusData, ThrowOnError>) => RequestResult<CheckUserChannelFollowStatusResponses, CheckUserChannelFollowStatusErrors, ThrowOnError, "fields">;
/**
 * Get members of a channel
 */
declare const getChannelMembers: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelMembersData, ThrowOnError>) => RequestResult<GetChannelMembersResponses, GetChannelMembersErrors, ThrowOnError, "fields">;
/**
 * Remove a user's invite from a channel
 */
declare const removeChannelInvite: <ThrowOnError extends boolean = false>(options: Options$1<RemoveChannelInviteData, ThrowOnError>) => RequestResult<RemoveChannelInviteResponses, RemoveChannelInviteErrors, ThrowOnError, "fields">;
/**
 * Get channel invites
 */
declare const getChannelInvites: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelInvitesData, ThrowOnError>) => RequestResult<GetChannelInvitesResponses, GetChannelInvitesErrors, ThrowOnError, "fields">;
/**
 * Accept a channel invite
 */
declare const acceptChannelInvite: <ThrowOnError extends boolean = false>(options: Options$1<AcceptChannelInviteData, ThrowOnError>) => RequestResult<AcceptChannelInviteResponses, AcceptChannelInviteErrors, ThrowOnError, "fields">;
/**
 * Invite a user to a channel
 */
declare const inviteUserToChannel: <ThrowOnError extends boolean = false>(options: Options$1<InviteUserToChannelData, ThrowOnError>) => RequestResult<InviteUserToChannelResponses, InviteUserToChannelErrors, ThrowOnError, "fields">;
/**
 * Get moderated casts for a channel
 */
declare const getChannelModeratedCasts: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelModeratedCastsData, ThrowOnError>) => RequestResult<GetChannelModeratedCastsResponses, GetChannelModeratedCastsErrors, ThrowOnError, "fields">;
/**
 * Get restricted users in a channel
 */
declare const getChannelRestrictedUsers: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelRestrictedUsersData, ThrowOnError>) => RequestResult<GetChannelRestrictedUsersResponses, GetChannelRestrictedUsersErrors, ThrowOnError, "fields">;
/**
 * Unban a user from a channel
 */
declare const unbanUserFromChannel: <ThrowOnError extends boolean = false>(options: Options$1<UnbanUserFromChannelData, ThrowOnError>) => RequestResult<UnbanUserFromChannelResponses, UnbanUserFromChannelErrors, ThrowOnError, "fields">;
/**
 * Get banned users in a channel
 */
declare const getChannelBannedUsers: <ThrowOnError extends boolean = false>(options: Options$1<GetChannelBannedUsersData, ThrowOnError>) => RequestResult<GetChannelBannedUsersResponses, GetChannelBannedUsersErrors, ThrowOnError, "fields">;
/**
 * Ban a user from a channel
 */
declare const banUserFromChannel: <ThrowOnError extends boolean = false>(options: Options$1<BanUserFromChannelData, ThrowOnError>) => RequestResult<BanUserFromChannelResponses, BanUserFromChannelErrors, ThrowOnError, "fields">;
/**
 * Unfollow a channel
 */
declare const unfollowChannel: <ThrowOnError extends boolean = false>(options: Options$1<UnfollowChannelData, ThrowOnError>) => RequestResult<UnfollowChannelResponses, UnfollowChannelErrors, ThrowOnError, "fields">;
/**
 * Follow a channel
 */
declare const followChannel: <ThrowOnError extends boolean = false>(options: Options$1<FollowChannelData, ThrowOnError>) => RequestResult<FollowChannelResponses, FollowChannelErrors, ThrowOnError, "fields">;
/**
 * Moderate a cast (e.g., hide it)
 */
declare const moderateCast: <ThrowOnError extends boolean = false>(options: Options$1<ModerateCastData, ThrowOnError>) => RequestResult<ModerateCastResponses, ModerateCastErrors, ThrowOnError, "fields">;
/**
 * Unpin a cast from a channel
 */
declare const unpinCastFromChannel: <ThrowOnError extends boolean = false>(options: Options$1<UnpinCastFromChannelData, ThrowOnError>) => RequestResult<UnpinCastFromChannelResponses, UnpinCastFromChannelErrors, ThrowOnError, "fields">;
/**
 * Pin a cast to a channel
 */
declare const pinCastToChannel: <ThrowOnError extends boolean = false>(options: Options$1<PinCastToChannelData, ThrowOnError>) => RequestResult<PinCastToChannelResponses, PinCastToChannelErrors, ThrowOnError, "fields">;
/**
 * Get discoverable actions
 */
declare const getDiscoverableActions: <ThrowOnError extends boolean = false>(options: Options$1<GetDiscoverableActionsData, ThrowOnError>) => RequestResult<GetDiscoverableActionsResponses, GetDiscoverableActionsErrors, ThrowOnError, "fields">;
/**
 * Get top discoverable composer actions
 */
declare const getDiscoverableComposerActions: <ThrowOnError extends boolean = false>(options: Options$1<GetDiscoverableComposerActionsData, ThrowOnError>) => RequestResult<GetDiscoverableComposerActionsResponses, GetDiscoverableComposerActionsErrors, ThrowOnError, "fields">;
/**
 * Unblock a user
 */
declare const unblockUser: <ThrowOnError extends boolean = false>(options: Options$1<UnblockUserData, ThrowOnError>) => RequestResult<UnblockUserResponses, UnblockUserErrors, ThrowOnError, "fields">;
/**
 * Get list of blocked users
 */
declare const getBlockedUsers: <ThrowOnError extends boolean = false>(options?: Options$1<GetBlockedUsersData, ThrowOnError>) => RequestResult<GetBlockedUsersResponses, GetBlockedUsersErrors, ThrowOnError, "fields">;
/**
 * Block a user
 */
declare const blockUser: <ThrowOnError extends boolean = false>(options: Options$1<BlockUserData, ThrowOnError>) => RequestResult<BlockUserResponses, BlockUserErrors, ThrowOnError, "fields">;
/**
 * Get account verifications
 */
declare const getAccountVerifications: <ThrowOnError extends boolean = false>(options: Options$1<GetAccountVerificationsData, ThrowOnError>) => RequestResult<GetAccountVerificationsResponses, GetAccountVerificationsErrors, ThrowOnError, "fields">;
/**
 * Get creator reward winners
 */
declare const getCreatorRewardWinners: <ThrowOnError extends boolean = false>(options?: Options$1<GetCreatorRewardWinnersData, ThrowOnError>) => RequestResult<GetCreatorRewardWinnersResponses, GetCreatorRewardWinnersErrors, ThrowOnError, "fields">;
/**
 * Get User Primary Address
 */
declare const getUserPrimaryAddress: <ThrowOnError extends boolean = false>(options: Options$1<GetUserPrimaryAddressData, ThrowOnError>) => RequestResult<GetUserPrimaryAddressResponses, GetUserPrimaryAddressErrors, ThrowOnError, "fields">;
/**
 * Get Multiple User Primary Addresses
 */
declare const getUserPrimaryAddresses: <ThrowOnError extends boolean = false>(options: Options$1<GetUserPrimaryAddressesData, ThrowOnError>) => RequestResult<GetUserPrimaryAddressesResponses, GetUserPrimaryAddressesErrors, ThrowOnError, "fields">;
/**
 * Get Starter Pack Members
 */
declare const getStarterPackMembers: <ThrowOnError extends boolean = false>(options: Options$1<GetStarterPackMembersData, ThrowOnError>) => RequestResult<GetStarterPackMembersResponses, GetStarterPackMembersErrors, ThrowOnError, "fields">;
/**
 * Send a Direct Cast via External API
 *
 * Send a programmatic Direct Cast to a recipient. The request must include a unique idempotency key.
 *
 */
declare const sendDirectCast: <ThrowOnError extends boolean = false>(options: Options$1<SendDirectCastData, ThrowOnError>) => RequestResult<SendDirectCastResponses, SendDirectCastErrors, ThrowOnError, "fields">;
/**
 * Get user by verification address
 *
 * Retrieves user information associated with the provided Ethereum verification address
 */
declare const getUserByVerificationAddress: <ThrowOnError extends boolean = false>(options: Options$1<GetUserByVerificationAddressData, ThrowOnError>) => RequestResult<GetUserByVerificationAddressResponses, GetUserByVerificationAddressErrors, ThrowOnError, "fields">;
/**
 * Get developer reward winners
 *
 * Provides access to all winners for a given period (week). Paginated, with the list of winners in rank order. Not authenticated.
 */
declare const getDeveloperRewardWinners: <ThrowOnError extends boolean = false>(options?: Options$1<GetDeveloperRewardWinnersData, ThrowOnError>) => RequestResult<GetDeveloperRewardWinnersResponses, GetDeveloperRewardWinnersErrors, ThrowOnError, "fields">;
/**
 * Get apps (frames) by author
 *
 * Retrieves a list of apps (aka "frames") created by a specific author on Warpcast, using their FID (Farcaster ID).
 * The response includes metadata for each app, including icons, URLs, and author profile details.
 *
 */
declare const getAppsByAuthor: <ThrowOnError extends boolean = false>(options: Options$1<GetAppsByAuthorData, ThrowOnError>) => RequestResult<GetAppsByAuthorResponses, GetAppsByAuthorErrors, ThrowOnError, "fields">;
/**
 * Retrieve domain manifest information
 *
 * Fetches verification and manifest information for a Farcaster domain
 */
declare const getDomainManifest: <ThrowOnError extends boolean = false>(options: Options$1<GetDomainManifestData, ThrowOnError>) => RequestResult<GetDomainManifestResponses, GetDomainManifestErrors, ThrowOnError, "fields">;
/**
 * Get trending topics
 *
 * Retrieves a list of currently trending topics on the platform.
 */
declare const getTrendingTopics: <ThrowOnError extends boolean = false>(options?: Options$1<GetTrendingTopicsData, ThrowOnError>) => RequestResult<GetTrendingTopicsResponses, GetTrendingTopicsErrors, ThrowOnError, "fields">;
/**
 * Fetch meta tags from a URL
 *
 * Retrieves metadata and Open Graph information from a specified URL
 */
declare const getMetaTags: <ThrowOnError extends boolean = false>(options: Options$1<GetMetaTagsData, ThrowOnError>) => RequestResult<GetMetaTagsResponses, GetMetaTagsErrors, ThrowOnError, "fields">;
/**
 * Fetch Farcaster JSON data from a domain
 *
 * Retrieves Farcaster account association and frame information for a specified domain
 */
declare const getFarcasterJson: <ThrowOnError extends boolean = false>(options: Options$1<GetFarcasterJsonData, ThrowOnError>) => RequestResult<GetFarcasterJsonResponses, GetFarcasterJsonErrors, ThrowOnError, "fields">;
/**
 * Retrieve domains owned by the authenticated user
 *
 * Returns a list of domains that are owned by the currently authenticated user.
 */
declare const getOwnedDomains: <ThrowOnError extends boolean = false>(options?: Options$1<GetOwnedDomainsData, ThrowOnError>) => RequestResult<GetOwnedDomainsResponses, GetOwnedDomainsErrors, ThrowOnError, "fields">;
/**
 * Get managed apps
 *
 * Retrieves a list of apps managed by the authenticated user.
 */
declare const getManagedApps: <ThrowOnError extends boolean = false>(options?: Options$1<GetManagedAppsData, ThrowOnError>) => RequestResult<GetManagedAppsResponses, GetManagedAppsErrors, ThrowOnError, "fields">;
/**
 * Retrieve API keys for the authenticated user
 *
 * Returns a list of API keys associated with the user's account, including active and revoked keys
 */
declare const getApiKeys: <ThrowOnError extends boolean = false>(options?: Options$1<GetApiKeysData, ThrowOnError>) => RequestResult<GetApiKeysResponses, GetApiKeysErrors, ThrowOnError, "fields">;
/**
 * Create a new API key
 *
 * Creates a new API key with the specified description and expiration date
 */
declare const createApiKey: <ThrowOnError extends boolean = false>(options: Options$1<CreateApiKeyData, ThrowOnError>) => RequestResult<CreateApiKeyResponses, CreateApiKeyErrors, ThrowOnError, "fields">;
/**
 * Revoke an API key
 *
 * Revokes an existing API key making it no longer valid for authentication
 */
declare const revokeApiKey: <ThrowOnError extends boolean = false>(options: Options$1<RevokeApiKeyData, ThrowOnError>) => RequestResult<RevokeApiKeyResponses, RevokeApiKeyErrors, ThrowOnError, "fields">;
/**
 * Get connected social accounts
 *
 * Retrieves a list of external social accounts connected to the user's Warpcast profile
 */
declare const getConnectedAccounts: <ThrowOnError extends boolean = false>(options?: Options$1<GetConnectedAccountsData, ThrowOnError>) => RequestResult<GetConnectedAccountsResponses, GetConnectedAccountsErrors, ThrowOnError, "fields">;
/**
 * Get casts from a user's profile
 *
 * Retrieves a list of casts published by a specific user identified by their Farcaster ID (FID).
 */
declare const getProfileCasts: <ThrowOnError extends boolean = false>(options: Options$1<GetProfileCastsData, ThrowOnError>) => RequestResult<GetProfileCastsResponses, GetProfileCastsErrors, ThrowOnError, "fields">;
/**
 * Retrieve liked casts by user FID
 */
declare const getUserLikedCasts: <ThrowOnError extends boolean = false>(options: Options$1<GetUserLikedCastsData, ThrowOnError>) => RequestResult<GetUserLikedCastsResponses, GetUserLikedCastsErrors, ThrowOnError, "fields">;
/**
 * Submit analytics events
 *
 * Submit one or more analytics events for tracking user activity.
 */
declare const submitAnalyticsEvents: <ThrowOnError extends boolean = false>(options: Options$1<SubmitAnalyticsEventsData, ThrowOnError>) => RequestResult<SubmitAnalyticsEventsResponses, SubmitAnalyticsEventsErrors, ThrowOnError, "fields">;
/**
 * Get analytics rollup for miniapps
 *
 * Retrieves analytics data for miniapps over a specified date range,
 * providing various metrics broken down by configured dimensions.
 *
 */
declare const getMiniAppAnalyticsRollup: <ThrowOnError extends boolean = false>(options: Options$1<GetMiniAppAnalyticsRollupData, ThrowOnError>) => RequestResult<GetMiniAppAnalyticsRollupResponses, GetMiniAppAnalyticsRollupErrors, ThrowOnError, "fields">;
/**
 * Inspect Mini App URL
 *
 * Validates a Mini App URL by checking for proper embedding code and manifest,
 * returning information about its compatibility with the Warpcast platform.
 *
 */
declare const inspectMiniAppUrl: <ThrowOnError extends boolean = false>(options: Options$1<InspectMiniAppUrlData, ThrowOnError>) => RequestResult<InspectMiniAppUrlResponses, InspectMiniAppUrlErrors, ThrowOnError, "fields">;
/**
 * Inspect an image URL
 *
 * Retrieves metadata and information about an image at a specified URL, including size, cache settings, and loading time.
 */
declare const inspectImageUrl: <ThrowOnError extends boolean = false>(options: Options$1<InspectImageUrlData, ThrowOnError>) => RequestResult<InspectImageUrlResponses, InspectImageUrlErrors, ThrowOnError, "fields">;
/**
 * Export user data for a specific mini app domain
 *
 * Retrieves a list of users who have interacted with a specified mini app domain, including their Farcaster IDs and notification tokens.
 */
declare const exportMiniAppUserData: <ThrowOnError extends boolean = false>(options: Options$1<ExportMiniAppUserDataData, ThrowOnError>) => RequestResult<ExportMiniAppUserDataResponses, ExportMiniAppUserDataErrors, ThrowOnError, "fields">;
/**
 * Register Statsig events
 *
 * Submits Statsig analytics events including gate exposures and other tracking events.
 */
declare const registerStatsigEvents: <ThrowOnError extends boolean = false>(options: Options$1<RegisterStatsigEventsData, ThrowOnError>) => RequestResult<RegisterStatsigEventsResponses, RegisterStatsigEventsErrors, ThrowOnError, "fields">;
//#endregion
//#region src/client/transformers.gen.d.ts
declare const getDirectCastInboxResponseTransformer: (data: any) => Promise<GetDirectCastInboxResponse>;
declare const getFeedItemsResponseTransformer: (data: any) => Promise<GetFeedItemsResponse>;
declare const getDirectCastConversationResponseTransformer: (data: any) => Promise<GetDirectCastConversationResponse>;
declare const getDirectCastConversationMessagesResponseTransformer: (data: any) => Promise<GetDirectCastConversationMessagesResponse>;
declare const getDirectCastConversationRecentMessagesResponseTransformer: (data: any) => Promise<GetDirectCastConversationRecentMessagesResponse>;
declare const getRewardsMetadataResponseTransformer: (data: any) => Promise<GetRewardsMetadataResponse>;
declare const getCastsByFidResponseTransformer: (data: any) => Promise<GetCastsByFidResponse>;
declare const createCastResponseTransformer: (data: any) => Promise<CreateCastResponse>;
declare const getCreatorRewardWinnersResponseTransformer: (data: any) => Promise<GetCreatorRewardWinnersResponse>;
declare const getStarterPackMembersResponseTransformer: (data: any) => Promise<GetStarterPackMembersResponse>;
declare const getApiKeysResponseTransformer: (data: any) => Promise<GetApiKeysResponse>;
declare const getProfileCastsResponseTransformer: (data: any) => Promise<GetProfileCastsResponse>;
declare const getUserLikedCastsResponseTransformer: (data: any) => Promise<GetUserLikedCastsResponse>;
declare const getMiniAppAnalyticsRollupResponseTransformer: (data: any) => Promise<GetMiniAppAnalyticsRollupResponse>;
//#endregion
//#region src/client/zod.gen.d.ts
declare const zProfilePicture: z.ZodObject<{
  url: z.ZodOptional<z.ZodURL>;
  verified: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
declare const zBio: z.ZodObject<{
  text: z.ZodOptional<z.ZodString>;
  mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
  channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
}, z.core.$strip>;
declare const zLocation: z.ZodObject<{
  placeId: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zProfile: z.ZodObject<{
  bio: z.ZodOptional<z.ZodObject<{
    text: z.ZodOptional<z.ZodString>;
    mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
  }, z.core.$strip>>;
  location: z.ZodOptional<z.ZodObject<{
    placeId: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zViewerContext: z.ZodObject<{
  following: z.ZodOptional<z.ZodBoolean>;
  followedBy: z.ZodOptional<z.ZodBoolean>;
  enableNotifications: z.ZodOptional<z.ZodBoolean>;
  canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
  hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
declare const zUser: z.ZodObject<{
  fid: z.ZodInt;
  username: z.ZodString;
  displayName: z.ZodString;
  pfp: z.ZodOptional<z.ZodObject<{
    url: z.ZodOptional<z.ZodURL>;
    verified: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
  profile: z.ZodOptional<z.ZodObject<{
    bio: z.ZodOptional<z.ZodObject<{
      text: z.ZodOptional<z.ZodString>;
      mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    }, z.core.$strip>>;
    location: z.ZodOptional<z.ZodObject<{
      placeId: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  followerCount: z.ZodOptional<z.ZodInt>;
  followingCount: z.ZodOptional<z.ZodInt>;
  viewerContext: z.ZodOptional<z.ZodObject<{
    following: z.ZodOptional<z.ZodBoolean>;
    followedBy: z.ZodOptional<z.ZodBoolean>;
    enableNotifications: z.ZodOptional<z.ZodBoolean>;
    canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
    hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zOnboardingState: z.ZodObject<{
  id: z.ZodOptional<z.ZodUUID>;
  email: z.ZodOptional<z.ZodEmail>;
  user: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  hasOnboarding: z.ZodOptional<z.ZodBoolean>;
  hasConfirmedEmail: z.ZodOptional<z.ZodBoolean>;
  handledConnectAddress: z.ZodOptional<z.ZodBoolean>;
  canRegisterUsername: z.ZodOptional<z.ZodBoolean>;
  needsRegistrationPayment: z.ZodOptional<z.ZodBoolean>;
  hasFid: z.ZodOptional<z.ZodBoolean>;
  hasFname: z.ZodOptional<z.ZodBoolean>;
  hasDelegatedSigner: z.ZodOptional<z.ZodBoolean>;
  hasSetupProfile: z.ZodOptional<z.ZodBoolean>;
  hasCompletedRegistration: z.ZodOptional<z.ZodBoolean>;
  hasStorage: z.ZodOptional<z.ZodBoolean>;
  handledPushNotificationsNudge: z.ZodOptional<z.ZodBoolean>;
  handledContactsNudge: z.ZodOptional<z.ZodBoolean>;
  handledInterestsNudge: z.ZodOptional<z.ZodBoolean>;
  hasValidPaidInvite: z.ZodOptional<z.ZodBoolean>;
  hasWarpcastWalletAddress: z.ZodOptional<z.ZodBoolean>;
  hasPhone: z.ZodOptional<z.ZodBoolean>;
  needsPhone: z.ZodOptional<z.ZodBoolean>;
  sponsoredRegisterEligible: z.ZodOptional<z.ZodBoolean>;
  geoRestricted: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
declare const zOnboardingStateResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    state: z.ZodOptional<z.ZodObject<{
      id: z.ZodOptional<z.ZodUUID>;
      email: z.ZodOptional<z.ZodEmail>;
      user: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      hasOnboarding: z.ZodOptional<z.ZodBoolean>;
      hasConfirmedEmail: z.ZodOptional<z.ZodBoolean>;
      handledConnectAddress: z.ZodOptional<z.ZodBoolean>;
      canRegisterUsername: z.ZodOptional<z.ZodBoolean>;
      needsRegistrationPayment: z.ZodOptional<z.ZodBoolean>;
      hasFid: z.ZodOptional<z.ZodBoolean>;
      hasFname: z.ZodOptional<z.ZodBoolean>;
      hasDelegatedSigner: z.ZodOptional<z.ZodBoolean>;
      hasSetupProfile: z.ZodOptional<z.ZodBoolean>;
      hasCompletedRegistration: z.ZodOptional<z.ZodBoolean>;
      hasStorage: z.ZodOptional<z.ZodBoolean>;
      handledPushNotificationsNudge: z.ZodOptional<z.ZodBoolean>;
      handledContactsNudge: z.ZodOptional<z.ZodBoolean>;
      handledInterestsNudge: z.ZodOptional<z.ZodBoolean>;
      hasValidPaidInvite: z.ZodOptional<z.ZodBoolean>;
      hasWarpcastWalletAddress: z.ZodOptional<z.ZodBoolean>;
      hasPhone: z.ZodOptional<z.ZodBoolean>;
      needsPhone: z.ZodOptional<z.ZodBoolean>;
      sponsoredRegisterEligible: z.ZodOptional<z.ZodBoolean>;
      geoRestricted: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * Generic 400 Bad Request error for simple error messages
 */
declare const zGenericBadRequestError: z.ZodObject<{
  errors: z.ZodArray<z.ZodObject<{
    message: z.ZodString;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zErrorResponse: z.ZodObject<{
  errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
    message: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>>;
}, z.core.$strip>;
declare const zUserWithExtras: z.ZodIntersection<z.ZodObject<{
  fid: z.ZodInt;
  username: z.ZodString;
  displayName: z.ZodString;
  pfp: z.ZodOptional<z.ZodObject<{
    url: z.ZodOptional<z.ZodURL>;
    verified: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
  profile: z.ZodOptional<z.ZodObject<{
    bio: z.ZodOptional<z.ZodObject<{
      text: z.ZodOptional<z.ZodString>;
      mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    }, z.core.$strip>>;
    location: z.ZodOptional<z.ZodObject<{
      placeId: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  followerCount: z.ZodOptional<z.ZodInt>;
  followingCount: z.ZodOptional<z.ZodInt>;
  viewerContext: z.ZodOptional<z.ZodObject<{
    following: z.ZodOptional<z.ZodBoolean>;
    followedBy: z.ZodOptional<z.ZodBoolean>;
    enableNotifications: z.ZodOptional<z.ZodBoolean>;
    canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
    hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
}, z.core.$strip>, z.ZodObject<{
  connectedAccounts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
}, z.core.$strip>>;
declare const zUserExtras: z.ZodObject<{
  fid: z.ZodOptional<z.ZodInt>;
  custodyAddress: z.ZodOptional<z.ZodString>;
  ethWallets: z.ZodOptional<z.ZodArray<z.ZodString>>;
  solanaWallets: z.ZodOptional<z.ZodArray<z.ZodString>>;
  walletLabels: z.ZodOptional<z.ZodArray<z.ZodObject<{
    address: z.ZodOptional<z.ZodString>;
    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
  }, z.core.$strip>>>;
  v2: z.ZodOptional<z.ZodBoolean>;
  publicSpamLabel: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zUserByFidResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    user: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>, z.ZodObject<{
      connectedAccounts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    }, z.core.$strip>>>;
    collectionsOwned: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    extras: z.ZodOptional<z.ZodObject<{
      fid: z.ZodOptional<z.ZodInt>;
      custodyAddress: z.ZodOptional<z.ZodString>;
      ethWallets: z.ZodOptional<z.ZodArray<z.ZodString>>;
      solanaWallets: z.ZodOptional<z.ZodArray<z.ZodString>>;
      walletLabels: z.ZodOptional<z.ZodArray<z.ZodObject<{
        address: z.ZodOptional<z.ZodString>;
        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
      }, z.core.$strip>>>;
      v2: z.ZodOptional<z.ZodBoolean>;
      publicSpamLabel: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * Represents a single validation error
 */
declare const zValidationError: z.ZodObject<{
  instancePath: z.ZodString;
  schemaPath: z.ZodString;
  keyword: z.ZodString;
  params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  message: z.ZodString;
}, z.core.$strip>;
/**
 * Standard 400 Bad Request error response
 */
declare const zBadRequestError: z.ZodObject<{
  errors: z.ZodArray<z.ZodObject<{
    instancePath: z.ZodString;
    schemaPath: z.ZodString;
    keyword: z.ZodString;
    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    message: z.ZodString;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zDirectCastMessageReaction: z.ZodObject<{
  reaction: z.ZodString;
  count: z.ZodInt;
  emoji: z.ZodOptional<z.ZodString>;
  userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
}, z.core.$strip>;
declare const zDirectCastMessageViewerContext: z.ZodObject<{
  isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
  focused: z.ZodOptional<z.ZodBoolean>;
  reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
declare const zDirectCastMessageMetadata: z.ZodObject<{
  casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
}, z.core.$strip>;
declare const zDirectCastMessageMention: z.ZodObject<{
  user: z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  textIndex: z.ZodInt;
  length: z.ZodInt;
}, z.core.$strip>;
declare const zDirectCastMessage: z.ZodObject<{
  conversationId: z.ZodString;
  senderFid: z.ZodInt;
  messageId: z.ZodString;
  serverTimestamp: z.ZodCoercedBigInt<unknown>;
  type: z.ZodEnum<{
    text: "text";
    reaction: "reaction";
    image: "image";
    link: "link";
    group_membership_addition: "group_membership_addition";
    pin_message: "pin_message";
    message_ttl_change: "message_ttl_change";
  }>;
  message: z.ZodString;
  hasMention: z.ZodBoolean;
  reactions: z.ZodArray<z.ZodObject<{
    reaction: z.ZodString;
    count: z.ZodInt;
    emoji: z.ZodOptional<z.ZodString>;
    userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
  }, z.core.$strip>>;
  isPinned: z.ZodBoolean;
  isDeleted: z.ZodBoolean;
  senderContext: z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  viewerContext: z.ZodOptional<z.ZodObject<{
    isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
    focused: z.ZodOptional<z.ZodBoolean>;
    reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
  }, z.core.$strip>>;
  inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
  metadata: z.ZodOptional<z.ZodObject<{
    casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>>;
  actionTargetUserContext: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  isProgrammatic: z.ZodOptional<z.ZodBoolean>;
  mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
    user: z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>;
    textIndex: z.ZodInt;
    length: z.ZodInt;
  }, z.core.$strip>>>;
}, z.core.$strip>;
declare const zDirectCastConversationViewerContext: z.ZodObject<{
  access: z.ZodOptional<z.ZodEnum<{
    "read-write": "read-write";
    "read-only": "read-only";
  }>>;
  category: z.ZodOptional<z.ZodString>;
  archived: z.ZodOptional<z.ZodBoolean>;
  lastReadAt: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
  muted: z.ZodOptional<z.ZodBoolean>;
  manuallyMarkedUnread: z.ZodOptional<z.ZodBoolean>;
  pinned: z.ZodOptional<z.ZodBoolean>;
  unreadCount: z.ZodOptional<z.ZodInt>;
  unreadMentionsCount: z.ZodOptional<z.ZodInt>;
  counterParty: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  tag: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zDirectCastConversation: z.ZodObject<{
  conversationId: z.ZodString;
  name: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
  photoUrl: z.ZodOptional<z.ZodURL>;
  adminFids: z.ZodArray<z.ZodInt>;
  removedFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
  participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>>;
  lastReadTime: z.ZodCoercedBigInt<unknown>;
  selfLastReadTime: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
  pinnedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
    conversationId: z.ZodString;
    senderFid: z.ZodInt;
    messageId: z.ZodString;
    serverTimestamp: z.ZodCoercedBigInt<unknown>;
    type: z.ZodEnum<{
      text: "text";
      reaction: "reaction";
      image: "image";
      link: "link";
      group_membership_addition: "group_membership_addition";
      pin_message: "pin_message";
      message_ttl_change: "message_ttl_change";
    }>;
    message: z.ZodString;
    hasMention: z.ZodBoolean;
    reactions: z.ZodArray<z.ZodObject<{
      reaction: z.ZodString;
      count: z.ZodInt;
      emoji: z.ZodOptional<z.ZodString>;
      userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
    }, z.core.$strip>>;
    isPinned: z.ZodBoolean;
    isDeleted: z.ZodBoolean;
    senderContext: z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
      focused: z.ZodOptional<z.ZodBoolean>;
      reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
    metadata: z.ZodOptional<z.ZodObject<{
      casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    }, z.core.$strip>>;
    actionTargetUserContext: z.ZodOptional<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    isProgrammatic: z.ZodOptional<z.ZodBoolean>;
    mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
      user: z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      textIndex: z.ZodInt;
      length: z.ZodInt;
    }, z.core.$strip>>>;
  }, z.core.$strip>>>;
  hasPinnedMessages: z.ZodOptional<z.ZodBoolean>;
  isGroup: z.ZodBoolean;
  isCollectionTokenGated: z.ZodOptional<z.ZodBoolean>;
  activeParticipantsCount: z.ZodOptional<z.ZodInt>;
  messageTTLDays: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
    Infinity: "Infinity";
  }>]>>;
  createdAt: z.ZodCoercedBigInt<unknown>;
  unreadCount: z.ZodOptional<z.ZodInt>;
  muted: z.ZodOptional<z.ZodBoolean>;
  hasMention: z.ZodOptional<z.ZodBoolean>;
  lastMessage: z.ZodOptional<z.ZodObject<{
    conversationId: z.ZodString;
    senderFid: z.ZodInt;
    messageId: z.ZodString;
    serverTimestamp: z.ZodCoercedBigInt<unknown>;
    type: z.ZodEnum<{
      text: "text";
      reaction: "reaction";
      image: "image";
      link: "link";
      group_membership_addition: "group_membership_addition";
      pin_message: "pin_message";
      message_ttl_change: "message_ttl_change";
    }>;
    message: z.ZodString;
    hasMention: z.ZodBoolean;
    reactions: z.ZodArray<z.ZodObject<{
      reaction: z.ZodString;
      count: z.ZodInt;
      emoji: z.ZodOptional<z.ZodString>;
      userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
    }, z.core.$strip>>;
    isPinned: z.ZodBoolean;
    isDeleted: z.ZodBoolean;
    senderContext: z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
      focused: z.ZodOptional<z.ZodBoolean>;
      reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
    metadata: z.ZodOptional<z.ZodObject<{
      casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    }, z.core.$strip>>;
    actionTargetUserContext: z.ZodOptional<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    isProgrammatic: z.ZodOptional<z.ZodBoolean>;
    mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
      user: z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      textIndex: z.ZodInt;
      length: z.ZodInt;
    }, z.core.$strip>>>;
  }, z.core.$strip>>;
  viewerContext: z.ZodObject<{
    access: z.ZodOptional<z.ZodEnum<{
      "read-write": "read-write";
      "read-only": "read-only";
    }>>;
    category: z.ZodOptional<z.ZodString>;
    archived: z.ZodOptional<z.ZodBoolean>;
    lastReadAt: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
    muted: z.ZodOptional<z.ZodBoolean>;
    manuallyMarkedUnread: z.ZodOptional<z.ZodBoolean>;
    pinned: z.ZodOptional<z.ZodBoolean>;
    unreadCount: z.ZodOptional<z.ZodInt>;
    unreadMentionsCount: z.ZodOptional<z.ZodInt>;
    counterParty: z.ZodOptional<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    tag: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zDirectCastInboxResult: z.ZodObject<{
  hasArchived: z.ZodBoolean;
  hasUnreadRequests: z.ZodBoolean;
  requestsCount: z.ZodInt;
  conversations: z.ZodArray<z.ZodObject<{
    conversationId: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    photoUrl: z.ZodOptional<z.ZodURL>;
    adminFids: z.ZodArray<z.ZodInt>;
    removedFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
    lastReadTime: z.ZodCoercedBigInt<unknown>;
    selfLastReadTime: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
    pinnedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
      conversationId: z.ZodString;
      senderFid: z.ZodInt;
      messageId: z.ZodString;
      serverTimestamp: z.ZodCoercedBigInt<unknown>;
      type: z.ZodEnum<{
        text: "text";
        reaction: "reaction";
        image: "image";
        link: "link";
        group_membership_addition: "group_membership_addition";
        pin_message: "pin_message";
        message_ttl_change: "message_ttl_change";
      }>;
      message: z.ZodString;
      hasMention: z.ZodBoolean;
      reactions: z.ZodArray<z.ZodObject<{
        reaction: z.ZodString;
        count: z.ZodInt;
        emoji: z.ZodOptional<z.ZodString>;
        userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      }, z.core.$strip>>;
      isPinned: z.ZodBoolean;
      isDeleted: z.ZodBoolean;
      senderContext: z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
        focused: z.ZodOptional<z.ZodBoolean>;
        reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
      }, z.core.$strip>>;
      inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
      metadata: z.ZodOptional<z.ZodObject<{
        casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      }, z.core.$strip>>;
      actionTargetUserContext: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      isProgrammatic: z.ZodOptional<z.ZodBoolean>;
      mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        user: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        textIndex: z.ZodInt;
        length: z.ZodInt;
      }, z.core.$strip>>>;
    }, z.core.$strip>>>;
    hasPinnedMessages: z.ZodOptional<z.ZodBoolean>;
    isGroup: z.ZodBoolean;
    isCollectionTokenGated: z.ZodOptional<z.ZodBoolean>;
    activeParticipantsCount: z.ZodOptional<z.ZodInt>;
    messageTTLDays: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
      Infinity: "Infinity";
    }>]>>;
    createdAt: z.ZodCoercedBigInt<unknown>;
    unreadCount: z.ZodOptional<z.ZodInt>;
    muted: z.ZodOptional<z.ZodBoolean>;
    hasMention: z.ZodOptional<z.ZodBoolean>;
    lastMessage: z.ZodOptional<z.ZodObject<{
      conversationId: z.ZodString;
      senderFid: z.ZodInt;
      messageId: z.ZodString;
      serverTimestamp: z.ZodCoercedBigInt<unknown>;
      type: z.ZodEnum<{
        text: "text";
        reaction: "reaction";
        image: "image";
        link: "link";
        group_membership_addition: "group_membership_addition";
        pin_message: "pin_message";
        message_ttl_change: "message_ttl_change";
      }>;
      message: z.ZodString;
      hasMention: z.ZodBoolean;
      reactions: z.ZodArray<z.ZodObject<{
        reaction: z.ZodString;
        count: z.ZodInt;
        emoji: z.ZodOptional<z.ZodString>;
        userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      }, z.core.$strip>>;
      isPinned: z.ZodBoolean;
      isDeleted: z.ZodBoolean;
      senderContext: z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
        focused: z.ZodOptional<z.ZodBoolean>;
        reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
      }, z.core.$strip>>;
      inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
      metadata: z.ZodOptional<z.ZodObject<{
        casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      }, z.core.$strip>>;
      actionTargetUserContext: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      isProgrammatic: z.ZodOptional<z.ZodBoolean>;
      mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        user: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        textIndex: z.ZodInt;
        length: z.ZodInt;
      }, z.core.$strip>>>;
    }, z.core.$strip>>;
    viewerContext: z.ZodObject<{
      access: z.ZodOptional<z.ZodEnum<{
        "read-write": "read-write";
        "read-only": "read-only";
      }>>;
      category: z.ZodOptional<z.ZodString>;
      archived: z.ZodOptional<z.ZodBoolean>;
      lastReadAt: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
      muted: z.ZodOptional<z.ZodBoolean>;
      manuallyMarkedUnread: z.ZodOptional<z.ZodBoolean>;
      pinned: z.ZodOptional<z.ZodBoolean>;
      unreadCount: z.ZodOptional<z.ZodInt>;
      unreadMentionsCount: z.ZodOptional<z.ZodInt>;
      counterParty: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      tag: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zPaginationCursor: z.ZodObject<{
  cursor: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zDirectCastInboxResponse: z.ZodObject<{
  result: z.ZodObject<{
    hasArchived: z.ZodBoolean;
    hasUnreadRequests: z.ZodBoolean;
    requestsCount: z.ZodInt;
    conversations: z.ZodArray<z.ZodObject<{
      conversationId: z.ZodString;
      name: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      photoUrl: z.ZodOptional<z.ZodURL>;
      adminFids: z.ZodArray<z.ZodInt>;
      removedFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>>;
      lastReadTime: z.ZodCoercedBigInt<unknown>;
      selfLastReadTime: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
      pinnedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
        conversationId: z.ZodString;
        senderFid: z.ZodInt;
        messageId: z.ZodString;
        serverTimestamp: z.ZodCoercedBigInt<unknown>;
        type: z.ZodEnum<{
          text: "text";
          reaction: "reaction";
          image: "image";
          link: "link";
          group_membership_addition: "group_membership_addition";
          pin_message: "pin_message";
          message_ttl_change: "message_ttl_change";
        }>;
        message: z.ZodString;
        hasMention: z.ZodBoolean;
        reactions: z.ZodArray<z.ZodObject<{
          reaction: z.ZodString;
          count: z.ZodInt;
          emoji: z.ZodOptional<z.ZodString>;
          userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
        }, z.core.$strip>>;
        isPinned: z.ZodBoolean;
        isDeleted: z.ZodBoolean;
        senderContext: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
          focused: z.ZodOptional<z.ZodBoolean>;
          reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
        metadata: z.ZodOptional<z.ZodObject<{
          casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        }, z.core.$strip>>;
        actionTargetUserContext: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        isProgrammatic: z.ZodOptional<z.ZodBoolean>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
          user: z.ZodObject<{
            fid: z.ZodInt;
            username: z.ZodString;
            displayName: z.ZodString;
            pfp: z.ZodOptional<z.ZodObject<{
              url: z.ZodOptional<z.ZodURL>;
              verified: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
            profile: z.ZodOptional<z.ZodObject<{
              bio: z.ZodOptional<z.ZodObject<{
                text: z.ZodOptional<z.ZodString>;
                mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
                channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              }, z.core.$strip>>;
              location: z.ZodOptional<z.ZodObject<{
                placeId: z.ZodOptional<z.ZodString>;
                description: z.ZodOptional<z.ZodString>;
              }, z.core.$strip>>;
            }, z.core.$strip>>;
            followerCount: z.ZodOptional<z.ZodInt>;
            followingCount: z.ZodOptional<z.ZodInt>;
            viewerContext: z.ZodOptional<z.ZodObject<{
              following: z.ZodOptional<z.ZodBoolean>;
              followedBy: z.ZodOptional<z.ZodBoolean>;
              enableNotifications: z.ZodOptional<z.ZodBoolean>;
              canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
              hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
          }, z.core.$strip>;
          textIndex: z.ZodInt;
          length: z.ZodInt;
        }, z.core.$strip>>>;
      }, z.core.$strip>>>;
      hasPinnedMessages: z.ZodOptional<z.ZodBoolean>;
      isGroup: z.ZodBoolean;
      isCollectionTokenGated: z.ZodOptional<z.ZodBoolean>;
      activeParticipantsCount: z.ZodOptional<z.ZodInt>;
      messageTTLDays: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
        Infinity: "Infinity";
      }>]>>;
      createdAt: z.ZodCoercedBigInt<unknown>;
      unreadCount: z.ZodOptional<z.ZodInt>;
      muted: z.ZodOptional<z.ZodBoolean>;
      hasMention: z.ZodOptional<z.ZodBoolean>;
      lastMessage: z.ZodOptional<z.ZodObject<{
        conversationId: z.ZodString;
        senderFid: z.ZodInt;
        messageId: z.ZodString;
        serverTimestamp: z.ZodCoercedBigInt<unknown>;
        type: z.ZodEnum<{
          text: "text";
          reaction: "reaction";
          image: "image";
          link: "link";
          group_membership_addition: "group_membership_addition";
          pin_message: "pin_message";
          message_ttl_change: "message_ttl_change";
        }>;
        message: z.ZodString;
        hasMention: z.ZodBoolean;
        reactions: z.ZodArray<z.ZodObject<{
          reaction: z.ZodString;
          count: z.ZodInt;
          emoji: z.ZodOptional<z.ZodString>;
          userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
        }, z.core.$strip>>;
        isPinned: z.ZodBoolean;
        isDeleted: z.ZodBoolean;
        senderContext: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
          focused: z.ZodOptional<z.ZodBoolean>;
          reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
        metadata: z.ZodOptional<z.ZodObject<{
          casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        }, z.core.$strip>>;
        actionTargetUserContext: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        isProgrammatic: z.ZodOptional<z.ZodBoolean>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
          user: z.ZodObject<{
            fid: z.ZodInt;
            username: z.ZodString;
            displayName: z.ZodString;
            pfp: z.ZodOptional<z.ZodObject<{
              url: z.ZodOptional<z.ZodURL>;
              verified: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
            profile: z.ZodOptional<z.ZodObject<{
              bio: z.ZodOptional<z.ZodObject<{
                text: z.ZodOptional<z.ZodString>;
                mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
                channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              }, z.core.$strip>>;
              location: z.ZodOptional<z.ZodObject<{
                placeId: z.ZodOptional<z.ZodString>;
                description: z.ZodOptional<z.ZodString>;
              }, z.core.$strip>>;
            }, z.core.$strip>>;
            followerCount: z.ZodOptional<z.ZodInt>;
            followingCount: z.ZodOptional<z.ZodInt>;
            viewerContext: z.ZodOptional<z.ZodObject<{
              following: z.ZodOptional<z.ZodBoolean>;
              followedBy: z.ZodOptional<z.ZodBoolean>;
              enableNotifications: z.ZodOptional<z.ZodBoolean>;
              canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
              hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
          }, z.core.$strip>;
          textIndex: z.ZodInt;
          length: z.ZodInt;
        }, z.core.$strip>>>;
      }, z.core.$strip>>;
      viewerContext: z.ZodObject<{
        access: z.ZodOptional<z.ZodEnum<{
          "read-write": "read-write";
          "read-only": "read-only";
        }>>;
        category: z.ZodOptional<z.ZodString>;
        archived: z.ZodOptional<z.ZodBoolean>;
        lastReadAt: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
        muted: z.ZodOptional<z.ZodBoolean>;
        manuallyMarkedUnread: z.ZodOptional<z.ZodBoolean>;
        pinned: z.ZodOptional<z.ZodBoolean>;
        unreadCount: z.ZodOptional<z.ZodInt>;
        unreadMentionsCount: z.ZodOptional<z.ZodInt>;
        counterParty: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        tag: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  next: z.ZodOptional<z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zCastAction: z.ZodObject<{
  id: z.ZodOptional<z.ZodString>;
  name: z.ZodOptional<z.ZodString>;
  octicon: z.ZodOptional<z.ZodString>;
  actionUrl: z.ZodOptional<z.ZodString>;
  action: z.ZodOptional<z.ZodObject<{
    actionType: z.ZodOptional<z.ZodString>;
    postUrl: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zUserAppContextResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    context: z.ZodOptional<z.ZodObject<{
      canAddLinks: z.ZodOptional<z.ZodBoolean>;
      showConnectedApps: z.ZodOptional<z.ZodBoolean>;
      signerRequestsEnabled: z.ZodOptional<z.ZodBoolean>;
      prompts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      adminForChannelKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
      modOfChannelKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
      memberOfChannelKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
      canEditAllChannels: z.ZodOptional<z.ZodBoolean>;
      canUploadVideo: z.ZodOptional<z.ZodBoolean>;
      statsigEnabled: z.ZodOptional<z.ZodBoolean>;
      shouldPromptForPushNotifications: z.ZodOptional<z.ZodBoolean>;
      shouldPromptForUserFollowsSyncContacts: z.ZodOptional<z.ZodBoolean>;
      castActions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        octicon: z.ZodOptional<z.ZodString>;
        actionUrl: z.ZodOptional<z.ZodString>;
        action: z.ZodOptional<z.ZodObject<{
          actionType: z.ZodOptional<z.ZodString>;
          postUrl: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>>;
      canAddCastAction: z.ZodOptional<z.ZodBoolean>;
      enabledCastAction: z.ZodOptional<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        octicon: z.ZodOptional<z.ZodString>;
        actionUrl: z.ZodOptional<z.ZodString>;
        action: z.ZodOptional<z.ZodObject<{
          actionType: z.ZodOptional<z.ZodString>;
          postUrl: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      notificationTabsV2: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>>;
      enabledVideoAutoplay: z.ZodOptional<z.ZodBoolean>;
      regularCastByteLimit: z.ZodOptional<z.ZodInt>;
      longCastByteLimit: z.ZodOptional<z.ZodInt>;
      newUserStatus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      country: z.ZodOptional<z.ZodString>;
      higherClientEventSamplingRateEnabled: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zUserPreferencesResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zChannel: z.ZodObject<{
  type: z.ZodOptional<z.ZodString>;
  key: z.ZodOptional<z.ZodString>;
  name: z.ZodOptional<z.ZodString>;
  imageUrl: z.ZodOptional<z.ZodString>;
  fastImageUrl: z.ZodOptional<z.ZodString>;
  feeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    type: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>>;
  description: z.ZodOptional<z.ZodString>;
  followerCount: z.ZodOptional<z.ZodInt>;
  memberCount: z.ZodOptional<z.ZodInt>;
  showCastSourceLabels: z.ZodOptional<z.ZodBoolean>;
  showCastTags: z.ZodOptional<z.ZodBoolean>;
  sectionRank: z.ZodOptional<z.ZodInt>;
  subscribable: z.ZodOptional<z.ZodBoolean>;
  publicCasting: z.ZodOptional<z.ZodBoolean>;
  inviteCode: z.ZodOptional<z.ZodString>;
  headerImageUrl: z.ZodOptional<z.ZodString>;
  headerAction: z.ZodOptional<z.ZodObject<{
    title: z.ZodOptional<z.ZodString>;
    target: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
  headerActionMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  viewerContext: z.ZodOptional<z.ZodObject<{
    following: z.ZodOptional<z.ZodBoolean>;
    isMember: z.ZodOptional<z.ZodBoolean>;
    hasUnseenItems: z.ZodOptional<z.ZodBoolean>;
    favoritePosition: z.ZodOptional<z.ZodInt>;
    activityRank: z.ZodOptional<z.ZodInt>;
    canCast: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zHighlightedChannelsResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    channels: z.ZodOptional<z.ZodArray<z.ZodObject<{
      type: z.ZodOptional<z.ZodString>;
      key: z.ZodOptional<z.ZodString>;
      name: z.ZodOptional<z.ZodString>;
      imageUrl: z.ZodOptional<z.ZodString>;
      fastImageUrl: z.ZodOptional<z.ZodString>;
      feeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        type: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>>;
      description: z.ZodOptional<z.ZodString>;
      followerCount: z.ZodOptional<z.ZodInt>;
      memberCount: z.ZodOptional<z.ZodInt>;
      showCastSourceLabels: z.ZodOptional<z.ZodBoolean>;
      showCastTags: z.ZodOptional<z.ZodBoolean>;
      sectionRank: z.ZodOptional<z.ZodInt>;
      subscribable: z.ZodOptional<z.ZodBoolean>;
      publicCasting: z.ZodOptional<z.ZodBoolean>;
      inviteCode: z.ZodOptional<z.ZodString>;
      headerImageUrl: z.ZodOptional<z.ZodString>;
      headerAction: z.ZodOptional<z.ZodObject<{
        title: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      headerActionMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        isMember: z.ZodOptional<z.ZodBoolean>;
        hasUnseenItems: z.ZodOptional<z.ZodBoolean>;
        favoritePosition: z.ZodOptional<z.ZodInt>;
        activityRank: z.ZodOptional<z.ZodInt>;
        canCast: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      defaultFeed: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zImageEmbed: z.ZodObject<{
  type: z.ZodOptional<z.ZodEnum<{
    image: "image";
  }>>;
  url: z.ZodOptional<z.ZodString>;
  sourceUrl: z.ZodOptional<z.ZodString>;
  media: z.ZodOptional<z.ZodObject<{
    version: z.ZodOptional<z.ZodString>;
    width: z.ZodOptional<z.ZodInt>;
    height: z.ZodOptional<z.ZodInt>;
    staticRaster: z.ZodOptional<z.ZodString>;
    mimeType: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
  alt: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zUrlEmbed: z.ZodObject<{
  type: z.ZodEnum<{
    url: "url";
  }>;
  openGraph: z.ZodObject<{
    url: z.ZodString;
    sourceUrl: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    domain: z.ZodOptional<z.ZodString>;
    image: z.ZodOptional<z.ZodString>;
    useLargeImage: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zVideoEmbed: z.ZodObject<{
  type: z.ZodOptional<z.ZodEnum<{
    video: "video";
  }>>;
}, z.core.$strip>;
declare const zRecaster: z.ZodObject<{
  fid: z.ZodOptional<z.ZodInt>;
  username: z.ZodOptional<z.ZodString>;
  displayName: z.ZodOptional<z.ZodString>;
  recastHash: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zCast: z.ZodObject<{
  hash: z.ZodString;
  threadHash: z.ZodOptional<z.ZodString>;
  parentHash: z.ZodOptional<z.ZodString>;
  parentSource: z.ZodOptional<z.ZodObject<{
    type: z.ZodOptional<z.ZodEnum<{
      url: "url";
    }>>;
    url: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
  author: z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  text: z.ZodString;
  timestamp: z.ZodCoercedBigInt<unknown>;
  mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>>;
  embeds: z.ZodOptional<z.ZodObject<{
    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
      type: z.ZodOptional<z.ZodEnum<{
        image: "image";
      }>>;
      url: z.ZodOptional<z.ZodString>;
      sourceUrl: z.ZodOptional<z.ZodString>;
      media: z.ZodOptional<z.ZodObject<{
        version: z.ZodOptional<z.ZodString>;
        width: z.ZodOptional<z.ZodInt>;
        height: z.ZodOptional<z.ZodInt>;
        staticRaster: z.ZodOptional<z.ZodString>;
        mimeType: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      alt: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    urls: z.ZodOptional<z.ZodArray<z.ZodObject<{
      type: z.ZodEnum<{
        url: "url";
      }>;
      openGraph: z.ZodObject<{
        url: z.ZodString;
        sourceUrl: z.ZodOptional<z.ZodString>;
        title: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        domain: z.ZodOptional<z.ZodString>;
        image: z.ZodOptional<z.ZodString>;
        useLargeImage: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>;
    }, z.core.$strip>>>;
    videos: z.ZodOptional<z.ZodArray<z.ZodObject<{
      type: z.ZodOptional<z.ZodEnum<{
        video: "video";
      }>>;
    }, z.core.$strip>>>;
    unknowns: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    processedCastText: z.ZodOptional<z.ZodString>;
    groupInvites: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>>;
  replies: z.ZodObject<{
    count: z.ZodInt;
  }, z.core.$strip>;
  reactions: z.ZodObject<{
    count: z.ZodInt;
  }, z.core.$strip>;
  recasts: z.ZodObject<{
    count: z.ZodInt;
    recasters: z.ZodOptional<z.ZodArray<z.ZodObject<{
      fid: z.ZodOptional<z.ZodInt>;
      username: z.ZodOptional<z.ZodString>;
      displayName: z.ZodOptional<z.ZodString>;
      recastHash: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
  }, z.core.$strip>;
  watches: z.ZodObject<{
    count: z.ZodInt;
  }, z.core.$strip>;
  recast: z.ZodOptional<z.ZodBoolean>;
  tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
    type: z.ZodOptional<z.ZodString>;
    id: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    imageUrl: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>>;
  quoteCount: z.ZodOptional<z.ZodInt>;
  combinedRecastCount: z.ZodOptional<z.ZodInt>;
  channel: z.ZodOptional<z.ZodObject<{
    key: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    imageUrl: z.ZodOptional<z.ZodString>;
    authorContext: z.ZodOptional<z.ZodObject<{
      role: z.ZodOptional<z.ZodString>;
      restricted: z.ZodOptional<z.ZodBoolean>;
      banned: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    authorRole: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
  viewerContext: z.ZodOptional<z.ZodObject<{
    reacted: z.ZodOptional<z.ZodBoolean>;
    recast: z.ZodOptional<z.ZodBoolean>;
    bookmarked: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zFeedItemsResponse: z.ZodObject<{
  result: z.ZodObject<{
    items: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      timestamp: z.ZodInt;
      cast: z.ZodObject<{
        hash: z.ZodString;
        threadHash: z.ZodOptional<z.ZodString>;
        parentHash: z.ZodOptional<z.ZodString>;
        parentSource: z.ZodOptional<z.ZodObject<{
          type: z.ZodOptional<z.ZodEnum<{
            url: "url";
          }>>;
          url: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        author: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        text: z.ZodString;
        timestamp: z.ZodCoercedBigInt<unknown>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>>;
        embeds: z.ZodOptional<z.ZodObject<{
          images: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodOptional<z.ZodEnum<{
              image: "image";
            }>>;
            url: z.ZodOptional<z.ZodString>;
            sourceUrl: z.ZodOptional<z.ZodString>;
            media: z.ZodOptional<z.ZodObject<{
              version: z.ZodOptional<z.ZodString>;
              width: z.ZodOptional<z.ZodInt>;
              height: z.ZodOptional<z.ZodInt>;
              staticRaster: z.ZodOptional<z.ZodString>;
              mimeType: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
            alt: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>>;
          urls: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
              url: "url";
            }>;
            openGraph: z.ZodObject<{
              url: z.ZodString;
              sourceUrl: z.ZodOptional<z.ZodString>;
              title: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
              domain: z.ZodOptional<z.ZodString>;
              image: z.ZodOptional<z.ZodString>;
              useLargeImage: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>;
          }, z.core.$strip>>>;
          videos: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodOptional<z.ZodEnum<{
              video: "video";
            }>>;
          }, z.core.$strip>>>;
          unknowns: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          processedCastText: z.ZodOptional<z.ZodString>;
          groupInvites: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        }, z.core.$strip>>;
        replies: z.ZodObject<{
          count: z.ZodInt;
        }, z.core.$strip>;
        reactions: z.ZodObject<{
          count: z.ZodInt;
        }, z.core.$strip>;
        recasts: z.ZodObject<{
          count: z.ZodInt;
          recasters: z.ZodOptional<z.ZodArray<z.ZodObject<{
            fid: z.ZodOptional<z.ZodInt>;
            username: z.ZodOptional<z.ZodString>;
            displayName: z.ZodOptional<z.ZodString>;
            recastHash: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>>;
        }, z.core.$strip>;
        watches: z.ZodObject<{
          count: z.ZodInt;
        }, z.core.$strip>;
        recast: z.ZodOptional<z.ZodBoolean>;
        tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
          type: z.ZodOptional<z.ZodString>;
          id: z.ZodOptional<z.ZodString>;
          name: z.ZodOptional<z.ZodString>;
          imageUrl: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        quoteCount: z.ZodOptional<z.ZodInt>;
        combinedRecastCount: z.ZodOptional<z.ZodInt>;
        channel: z.ZodOptional<z.ZodObject<{
          key: z.ZodOptional<z.ZodString>;
          name: z.ZodOptional<z.ZodString>;
          imageUrl: z.ZodOptional<z.ZodString>;
          authorContext: z.ZodOptional<z.ZodObject<{
            role: z.ZodOptional<z.ZodString>;
            restricted: z.ZodOptional<z.ZodBoolean>;
            banned: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          authorRole: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          reacted: z.ZodOptional<z.ZodBoolean>;
          recast: z.ZodOptional<z.ZodBoolean>;
          bookmarked: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      otherParticipants: z.ZodOptional<z.ZodArray<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>>;
    }, z.core.$strip>>;
    latestMainCastTimestamp: z.ZodOptional<z.ZodInt>;
    feedTopSeenAtTimestamp: z.ZodOptional<z.ZodInt>;
    replaceFeed: z.ZodBoolean;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGenericResponse: z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>;
declare const zUserResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodObject<{
    user: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>, z.ZodObject<{
      connectedAccounts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    }, z.core.$strip>>>;
    collectionsOwned: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    extras: z.ZodOptional<z.ZodObject<{
      fid: z.ZodOptional<z.ZodInt>;
      custodyAddress: z.ZodOptional<z.ZodString>;
      ethWallets: z.ZodOptional<z.ZodArray<z.ZodString>>;
      solanaWallets: z.ZodOptional<z.ZodArray<z.ZodString>>;
      walletLabels: z.ZodOptional<z.ZodArray<z.ZodObject<{
        address: z.ZodOptional<z.ZodString>;
        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
      }, z.core.$strip>>>;
      v2: z.ZodOptional<z.ZodBoolean>;
      publicSpamLabel: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>>;
declare const zPaginatedResponse: z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
  next: z.ZodOptional<z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zSuggestedUsersResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
  next: z.ZodOptional<z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    users: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zFavoriteFramesResponse: z.ZodObject<{
  result: z.ZodObject<{
    frames: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zChannelStreaksResponse: z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>;
declare const zUnseenCountsResponse: z.ZodObject<{
  result: z.ZodObject<{
    notificationsCount: z.ZodOptional<z.ZodInt>;
    notificationTabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
      tab: z.ZodString;
      unseenCount: z.ZodInt;
    }, z.core.$strip>>>;
    inboxCount: z.ZodOptional<z.ZodInt>;
    channelFeeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
      channelKey: z.ZodString;
      feedType: z.ZodString;
      hasNewItems: z.ZodBoolean;
    }, z.core.$strip>>>;
    warpTransactionCount: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUserThreadCastsResponse: z.ZodObject<{
  result: z.ZodObject<{
    casts: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zChannelFollowersYouKnowResponse: z.ZodObject<{
  result: z.ZodObject<{
    users: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    totalCount: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSuccessResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    success: z.ZodBoolean;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zNotificationsResponse: z.ZodObject<{
  result: z.ZodObject<{
    notifications: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      type: z.ZodEnum<{
        recast: "recast";
        "channel-pinned-cast": "channel-pinned-cast";
        "channel-role-invite": "channel-role-invite";
        "new-cast-in-channel": "new-cast-in-channel";
        "cast-mention": "cast-mention";
        "cast-quote": "cast-quote";
        "cast-reaction": "cast-reaction";
        "cast-reply": "cast-reply";
        "dormant-user-new-cast": "dormant-user-new-cast";
        follow: "follow";
        "mini-app": "mini-app";
        "new-article": "new-article";
        "new-cast": "new-cast";
      }>;
      latestTimestamp: z.ZodCoercedBigInt<unknown>;
      totalItemCount: z.ZodInt;
      previewItems: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      isUnread: z.ZodBoolean;
      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>>;
    next: z.ZodOptional<z.ZodObject<{
      cursor: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zDirectCastConversationResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    conversation: z.ZodObject<{
      conversationId: z.ZodString;
      name: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      photoUrl: z.ZodOptional<z.ZodURL>;
      adminFids: z.ZodArray<z.ZodInt>;
      removedFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>>;
      lastReadTime: z.ZodCoercedBigInt<unknown>;
      selfLastReadTime: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
      pinnedMessages: z.ZodOptional<z.ZodArray<z.ZodObject<{
        conversationId: z.ZodString;
        senderFid: z.ZodInt;
        messageId: z.ZodString;
        serverTimestamp: z.ZodCoercedBigInt<unknown>;
        type: z.ZodEnum<{
          text: "text";
          reaction: "reaction";
          image: "image";
          link: "link";
          group_membership_addition: "group_membership_addition";
          pin_message: "pin_message";
          message_ttl_change: "message_ttl_change";
        }>;
        message: z.ZodString;
        hasMention: z.ZodBoolean;
        reactions: z.ZodArray<z.ZodObject<{
          reaction: z.ZodString;
          count: z.ZodInt;
          emoji: z.ZodOptional<z.ZodString>;
          userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
        }, z.core.$strip>>;
        isPinned: z.ZodBoolean;
        isDeleted: z.ZodBoolean;
        senderContext: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
          focused: z.ZodOptional<z.ZodBoolean>;
          reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
        metadata: z.ZodOptional<z.ZodObject<{
          casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        }, z.core.$strip>>;
        actionTargetUserContext: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        isProgrammatic: z.ZodOptional<z.ZodBoolean>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
          user: z.ZodObject<{
            fid: z.ZodInt;
            username: z.ZodString;
            displayName: z.ZodString;
            pfp: z.ZodOptional<z.ZodObject<{
              url: z.ZodOptional<z.ZodURL>;
              verified: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
            profile: z.ZodOptional<z.ZodObject<{
              bio: z.ZodOptional<z.ZodObject<{
                text: z.ZodOptional<z.ZodString>;
                mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
                channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              }, z.core.$strip>>;
              location: z.ZodOptional<z.ZodObject<{
                placeId: z.ZodOptional<z.ZodString>;
                description: z.ZodOptional<z.ZodString>;
              }, z.core.$strip>>;
            }, z.core.$strip>>;
            followerCount: z.ZodOptional<z.ZodInt>;
            followingCount: z.ZodOptional<z.ZodInt>;
            viewerContext: z.ZodOptional<z.ZodObject<{
              following: z.ZodOptional<z.ZodBoolean>;
              followedBy: z.ZodOptional<z.ZodBoolean>;
              enableNotifications: z.ZodOptional<z.ZodBoolean>;
              canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
              hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
          }, z.core.$strip>;
          textIndex: z.ZodInt;
          length: z.ZodInt;
        }, z.core.$strip>>>;
      }, z.core.$strip>>>;
      hasPinnedMessages: z.ZodOptional<z.ZodBoolean>;
      isGroup: z.ZodBoolean;
      isCollectionTokenGated: z.ZodOptional<z.ZodBoolean>;
      activeParticipantsCount: z.ZodOptional<z.ZodInt>;
      messageTTLDays: z.ZodOptional<z.ZodUnion<readonly [z.ZodInt, z.ZodEnum<{
        Infinity: "Infinity";
      }>]>>;
      createdAt: z.ZodCoercedBigInt<unknown>;
      unreadCount: z.ZodOptional<z.ZodInt>;
      muted: z.ZodOptional<z.ZodBoolean>;
      hasMention: z.ZodOptional<z.ZodBoolean>;
      lastMessage: z.ZodOptional<z.ZodObject<{
        conversationId: z.ZodString;
        senderFid: z.ZodInt;
        messageId: z.ZodString;
        serverTimestamp: z.ZodCoercedBigInt<unknown>;
        type: z.ZodEnum<{
          text: "text";
          reaction: "reaction";
          image: "image";
          link: "link";
          group_membership_addition: "group_membership_addition";
          pin_message: "pin_message";
          message_ttl_change: "message_ttl_change";
        }>;
        message: z.ZodString;
        hasMention: z.ZodBoolean;
        reactions: z.ZodArray<z.ZodObject<{
          reaction: z.ZodString;
          count: z.ZodInt;
          emoji: z.ZodOptional<z.ZodString>;
          userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
        }, z.core.$strip>>;
        isPinned: z.ZodBoolean;
        isDeleted: z.ZodBoolean;
        senderContext: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
          focused: z.ZodOptional<z.ZodBoolean>;
          reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
        metadata: z.ZodOptional<z.ZodObject<{
          casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
          medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        }, z.core.$strip>>;
        actionTargetUserContext: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        isProgrammatic: z.ZodOptional<z.ZodBoolean>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
          user: z.ZodObject<{
            fid: z.ZodInt;
            username: z.ZodString;
            displayName: z.ZodString;
            pfp: z.ZodOptional<z.ZodObject<{
              url: z.ZodOptional<z.ZodURL>;
              verified: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
            profile: z.ZodOptional<z.ZodObject<{
              bio: z.ZodOptional<z.ZodObject<{
                text: z.ZodOptional<z.ZodString>;
                mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
                channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              }, z.core.$strip>>;
              location: z.ZodOptional<z.ZodObject<{
                placeId: z.ZodOptional<z.ZodString>;
                description: z.ZodOptional<z.ZodString>;
              }, z.core.$strip>>;
            }, z.core.$strip>>;
            followerCount: z.ZodOptional<z.ZodInt>;
            followingCount: z.ZodOptional<z.ZodInt>;
            viewerContext: z.ZodOptional<z.ZodObject<{
              following: z.ZodOptional<z.ZodBoolean>;
              followedBy: z.ZodOptional<z.ZodBoolean>;
              enableNotifications: z.ZodOptional<z.ZodBoolean>;
              canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
              hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
          }, z.core.$strip>;
          textIndex: z.ZodInt;
          length: z.ZodInt;
        }, z.core.$strip>>>;
      }, z.core.$strip>>;
      viewerContext: z.ZodObject<{
        access: z.ZodOptional<z.ZodEnum<{
          "read-write": "read-write";
          "read-only": "read-only";
        }>>;
        category: z.ZodOptional<z.ZodString>;
        archived: z.ZodOptional<z.ZodBoolean>;
        lastReadAt: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
        muted: z.ZodOptional<z.ZodBoolean>;
        manuallyMarkedUnread: z.ZodOptional<z.ZodBoolean>;
        pinned: z.ZodOptional<z.ZodBoolean>;
        unreadCount: z.ZodOptional<z.ZodInt>;
        unreadMentionsCount: z.ZodOptional<z.ZodInt>;
        counterParty: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        tag: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>;
    }, z.core.$strip>;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zDirectCastConversationCategorizationRequest: z.ZodObject<{
  conversationId: z.ZodString;
  category: z.ZodString;
}, z.core.$strip>;
declare const zDirectCastConversationMessagesResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
  next: z.ZodOptional<z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    messages: z.ZodArray<z.ZodObject<{
      conversationId: z.ZodString;
      senderFid: z.ZodInt;
      messageId: z.ZodString;
      serverTimestamp: z.ZodCoercedBigInt<unknown>;
      type: z.ZodEnum<{
        text: "text";
        reaction: "reaction";
        image: "image";
        link: "link";
        group_membership_addition: "group_membership_addition";
        pin_message: "pin_message";
        message_ttl_change: "message_ttl_change";
      }>;
      message: z.ZodString;
      hasMention: z.ZodBoolean;
      reactions: z.ZodArray<z.ZodObject<{
        reaction: z.ZodString;
        count: z.ZodInt;
        emoji: z.ZodOptional<z.ZodString>;
        userFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      }, z.core.$strip>>;
      isPinned: z.ZodBoolean;
      isDeleted: z.ZodBoolean;
      senderContext: z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        isLastReadMessage: z.ZodOptional<z.ZodBoolean>;
        focused: z.ZodOptional<z.ZodBoolean>;
        reactions: z.ZodOptional<z.ZodArray<z.ZodString>>;
      }, z.core.$strip>>;
      inReplyTo: z.ZodOptional<z.ZodLazy<any>>;
      metadata: z.ZodOptional<z.ZodObject<{
        casts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        urls: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        medias: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      }, z.core.$strip>>;
      actionTargetUserContext: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      isProgrammatic: z.ZodOptional<z.ZodBoolean>;
      mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        user: z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>;
        textIndex: z.ZodInt;
        length: z.ZodInt;
      }, z.core.$strip>>>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zDirectCastConversationMessageTtlRequest: z.ZodObject<{
  conversationId: z.ZodString;
  ttl: z.ZodInt;
}, z.core.$strip>;
declare const zDirectCastConversationNotificationsRequest: z.ZodObject<{
  conversationId: z.ZodString;
  muted: z.ZodBoolean;
}, z.core.$strip>;
declare const zDirectCastSendRequest: z.ZodObject<{
  conversationId: z.ZodString;
  recipientFids: z.ZodArray<z.ZodInt>;
  messageId: z.ZodString;
  type: z.ZodEnum<{
    text: "text";
    reaction: "reaction";
    image: "image";
    link: "link";
  }>;
  message: z.ZodString;
  inReplyToId: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zDirectCastManuallyMarkUnreadRequest: z.ZodObject<{
  conversationId: z.ZodString;
}, z.core.$strip>;
declare const zDirectCastMessageReactionRequest: z.ZodObject<{
  conversationId: z.ZodString;
  messageId: z.ZodString;
  reaction: z.ZodString;
}, z.core.$strip>;
declare const zDirectCastPinConversationRequest: z.ZodObject<{
  conversationId: z.ZodString;
}, z.core.$strip>;
declare const zDiscoverChannelsResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    channels: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zInvitesAvailableResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    allocatedInvitesCount: z.ZodInt;
    availableInvitesCount: z.ZodInt;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zSponsoredInvitesResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    invites: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zRewardsLeaderboardResponse: z.ZodObject<{
  result: z.ZodObject<{
    leaderboard: z.ZodObject<{
      type: z.ZodString;
      users: z.ZodArray<z.ZodObject<{
        user: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        score: z.ZodOptional<z.ZodInt>;
        rank: z.ZodOptional<z.ZodInt>;
      }, z.core.$strip>>;
    }, z.core.$strip>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zRewardsScoresResponse: z.ZodObject<{
  result: z.ZodObject<{
    scores: z.ZodArray<z.ZodObject<{
      type: z.ZodOptional<z.ZodString>;
      user: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      allTimeScore: z.ZodOptional<z.ZodInt>;
      currentPeriodScore: z.ZodOptional<z.ZodInt>;
      previousPeriodScore: z.ZodOptional<z.ZodInt>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zRewardsMetadataResponse: z.ZodObject<{
  result: z.ZodObject<{
    metadata: z.ZodOptional<z.ZodObject<{
      type: z.ZodString;
      lastUpdateTimestamp: z.ZodCoercedBigInt<unknown>;
      currentPeriodStartTimestamp: z.ZodCoercedBigInt<unknown>;
      currentPeriodEndTimestamp: z.ZodCoercedBigInt<unknown>;
      tiers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      proportionalPayout: z.ZodOptional<z.ZodObject<{
        numWinners: z.ZodOptional<z.ZodInt>;
        totalRewardCents: z.ZodOptional<z.ZodInt>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zBookmarkedCast: z.ZodRecord<z.ZodString, z.ZodUnknown>;
declare const zBookmarkedCastsResponse: z.ZodObject<{
  result: z.ZodObject<{
    bookmarks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zStarterPack: z.ZodObject<{
  id: z.ZodString;
  creator: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  name: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
  openGraphImageUrl: z.ZodOptional<z.ZodURL>;
  itemCount: z.ZodOptional<z.ZodInt>;
  items: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
declare const zStarterPacksResponse: z.ZodObject<{
  result: z.ZodObject<{
    starterPacks: z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      creator: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      name: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      openGraphImageUrl: z.ZodOptional<z.ZodURL>;
      itemCount: z.ZodOptional<z.ZodInt>;
      items: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zStarterPackResponse: z.ZodObject<{
  result: z.ZodObject<{
    starterPack: z.ZodObject<{
      id: z.ZodString;
      creator: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      name: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      openGraphImageUrl: z.ZodOptional<z.ZodURL>;
      itemCount: z.ZodOptional<z.ZodInt>;
      items: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zStarterPackUpdateRequest: z.ZodObject<{
  id: z.ZodString;
  name: z.ZodString;
  description: z.ZodString;
  fids: z.ZodArray<z.ZodInt>;
  labels: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
declare const zStarterPackUsersResponse: z.ZodObject<{
  result: z.ZodObject<{
    users: z.ZodArray<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zChannelResponse: z.ZodObject<{
  result: z.ZodObject<{
    channel: z.ZodOptional<z.ZodObject<{
      type: z.ZodOptional<z.ZodString>;
      key: z.ZodOptional<z.ZodString>;
      name: z.ZodOptional<z.ZodString>;
      imageUrl: z.ZodOptional<z.ZodString>;
      fastImageUrl: z.ZodOptional<z.ZodString>;
      feeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        type: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>>;
      description: z.ZodOptional<z.ZodString>;
      followerCount: z.ZodOptional<z.ZodInt>;
      memberCount: z.ZodOptional<z.ZodInt>;
      showCastSourceLabels: z.ZodOptional<z.ZodBoolean>;
      showCastTags: z.ZodOptional<z.ZodBoolean>;
      sectionRank: z.ZodOptional<z.ZodInt>;
      subscribable: z.ZodOptional<z.ZodBoolean>;
      publicCasting: z.ZodOptional<z.ZodBoolean>;
      inviteCode: z.ZodOptional<z.ZodString>;
      headerImageUrl: z.ZodOptional<z.ZodString>;
      headerAction: z.ZodOptional<z.ZodObject<{
        title: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      headerActionMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        isMember: z.ZodOptional<z.ZodBoolean>;
        hasUnseenItems: z.ZodOptional<z.ZodBoolean>;
        favoritePosition: z.ZodOptional<z.ZodInt>;
        activityRank: z.ZodOptional<z.ZodInt>;
        canCast: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zChannelUsersResponse: z.ZodObject<{
  result: z.ZodObject<{
    users: z.ZodOptional<z.ZodArray<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUsersResponse: z.ZodObject<{
  result: z.ZodObject<{
    users: z.ZodArray<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUsersWithCountResponse: z.ZodObject<{
  result: z.ZodObject<{
    users: z.ZodArray<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    totalCount: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zFrameApp: z.ZodRecord<z.ZodString, z.ZodUnknown>;
declare const zFrameAppsResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    frames: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
/**
 * Context information for the viewer
 */
declare const zMiniAppViewerContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
declare const zMiniApp: z.ZodObject<{
  domain: z.ZodOptional<z.ZodString>;
  name: z.ZodOptional<z.ZodString>;
  iconUrl: z.ZodOptional<z.ZodString>;
  homeUrl: z.ZodOptional<z.ZodString>;
  author: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  supportsNotifications: z.ZodOptional<z.ZodBoolean>;
  id: z.ZodOptional<z.ZodString>;
  shortId: z.ZodOptional<z.ZodString>;
  imageUrl: z.ZodOptional<z.ZodString>;
  buttonTitle: z.ZodOptional<z.ZodString>;
  splashImageUrl: z.ZodOptional<z.ZodString>;
  splashBackgroundColor: z.ZodOptional<z.ZodString>;
  castShareUrl: z.ZodOptional<z.ZodString>;
  subtitle: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
  tagline: z.ZodOptional<z.ZodString>;
  heroImageUrl: z.ZodOptional<z.ZodString>;
  primaryCategory: z.ZodOptional<z.ZodString>;
  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
  screenshotUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
  noindex: z.ZodOptional<z.ZodBoolean>;
  ogTitle: z.ZodOptional<z.ZodString>;
  ogDescription: z.ZodOptional<z.ZodString>;
  ogImageUrl: z.ZodOptional<z.ZodString>;
  requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
  requiredChains: z.ZodOptional<z.ZodArray<z.ZodString>>;
  viewerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
declare const zRankedMiniApp: z.ZodObject<{
  rank: z.ZodOptional<z.ZodInt>;
  miniApp: z.ZodOptional<z.ZodObject<{
    domain: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    iconUrl: z.ZodOptional<z.ZodString>;
    homeUrl: z.ZodOptional<z.ZodString>;
    author: z.ZodOptional<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    supportsNotifications: z.ZodOptional<z.ZodBoolean>;
    id: z.ZodOptional<z.ZodString>;
    shortId: z.ZodOptional<z.ZodString>;
    imageUrl: z.ZodOptional<z.ZodString>;
    buttonTitle: z.ZodOptional<z.ZodString>;
    splashImageUrl: z.ZodOptional<z.ZodString>;
    splashBackgroundColor: z.ZodOptional<z.ZodString>;
    castShareUrl: z.ZodOptional<z.ZodString>;
    subtitle: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    tagline: z.ZodOptional<z.ZodString>;
    heroImageUrl: z.ZodOptional<z.ZodString>;
    primaryCategory: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    screenshotUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
    noindex: z.ZodOptional<z.ZodBoolean>;
    ogTitle: z.ZodOptional<z.ZodString>;
    ogDescription: z.ZodOptional<z.ZodString>;
    ogImageUrl: z.ZodOptional<z.ZodString>;
    requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
    requiredChains: z.ZodOptional<z.ZodArray<z.ZodString>>;
    viewerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  }, z.core.$strip>>;
  rank72hChange: z.ZodOptional<z.ZodInt>;
}, z.core.$strip>;
declare const zTopMiniAppsResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    miniApps: z.ZodOptional<z.ZodArray<z.ZodObject<{
      rank: z.ZodOptional<z.ZodInt>;
      miniApp: z.ZodOptional<z.ZodObject<{
        domain: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        iconUrl: z.ZodOptional<z.ZodString>;
        homeUrl: z.ZodOptional<z.ZodString>;
        author: z.ZodOptional<z.ZodObject<{
          fid: z.ZodInt;
          username: z.ZodString;
          displayName: z.ZodString;
          pfp: z.ZodOptional<z.ZodObject<{
            url: z.ZodOptional<z.ZodURL>;
            verified: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
          profile: z.ZodOptional<z.ZodObject<{
            bio: z.ZodOptional<z.ZodObject<{
              text: z.ZodOptional<z.ZodString>;
              mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
              channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            }, z.core.$strip>>;
            location: z.ZodOptional<z.ZodObject<{
              placeId: z.ZodOptional<z.ZodString>;
              description: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
          }, z.core.$strip>>;
          followerCount: z.ZodOptional<z.ZodInt>;
          followingCount: z.ZodOptional<z.ZodInt>;
          viewerContext: z.ZodOptional<z.ZodObject<{
            following: z.ZodOptional<z.ZodBoolean>;
            followedBy: z.ZodOptional<z.ZodBoolean>;
            enableNotifications: z.ZodOptional<z.ZodBoolean>;
            canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
            hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        supportsNotifications: z.ZodOptional<z.ZodBoolean>;
        id: z.ZodOptional<z.ZodString>;
        shortId: z.ZodOptional<z.ZodString>;
        imageUrl: z.ZodOptional<z.ZodString>;
        buttonTitle: z.ZodOptional<z.ZodString>;
        splashImageUrl: z.ZodOptional<z.ZodString>;
        splashBackgroundColor: z.ZodOptional<z.ZodString>;
        castShareUrl: z.ZodOptional<z.ZodString>;
        subtitle: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        tagline: z.ZodOptional<z.ZodString>;
        heroImageUrl: z.ZodOptional<z.ZodString>;
        primaryCategory: z.ZodOptional<z.ZodString>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        screenshotUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
        noindex: z.ZodOptional<z.ZodBoolean>;
        ogTitle: z.ZodOptional<z.ZodString>;
        ogDescription: z.ZodOptional<z.ZodString>;
        ogImageUrl: z.ZodOptional<z.ZodString>;
        requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
        requiredChains: z.ZodOptional<z.ZodArray<z.ZodString>>;
        viewerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      }, z.core.$strip>>;
      rank72hChange: z.ZodOptional<z.ZodInt>;
    }, z.core.$strip>>>;
    next: z.ZodOptional<z.ZodObject<{
      cursor: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zVerifiedAddress: z.ZodObject<{
  fid: z.ZodOptional<z.ZodInt>;
  address: z.ZodOptional<z.ZodString>;
  timestamp: z.ZodOptional<z.ZodInt>;
  version: z.ZodOptional<z.ZodString>;
  protocol: z.ZodOptional<z.ZodString>;
  isPrimary: z.ZodOptional<z.ZodBoolean>;
  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
declare const zMutedKeywordProperties: z.ZodObject<{
  channels: z.ZodOptional<z.ZodBoolean>;
  frames: z.ZodOptional<z.ZodBoolean>;
  notifications: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
declare const zMutedKeyword: z.ZodObject<{
  keyword: z.ZodString;
  properties: z.ZodObject<{
    channels: z.ZodOptional<z.ZodBoolean>;
    frames: z.ZodOptional<z.ZodBoolean>;
    notifications: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zMutedKeywordsResponse: z.ZodObject<{
  success: z.ZodBoolean;
  result: z.ZodObject<{
    keywords: z.ZodArray<z.ZodString>;
    mutedKeywords: z.ZodArray<z.ZodObject<{
      keyword: z.ZodString;
      properties: z.ZodObject<{
        channels: z.ZodOptional<z.ZodBoolean>;
        frames: z.ZodOptional<z.ZodBoolean>;
        notifications: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zCastHashResponse: z.ZodObject<{
  result: z.ZodObject<{
    castHash: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zAttachEmbedsResponse: z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>;
declare const zCastRecastersResponse: z.ZodObject<{
  result: z.ZodObject<{
    users: z.ZodOptional<z.ZodArray<z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zCastQuote: z.ZodObject<{
  hash: z.ZodOptional<z.ZodString>;
  threadHash: z.ZodOptional<z.ZodString>;
  parentSource: z.ZodOptional<z.ZodObject<{
    type: z.ZodOptional<z.ZodString>;
    url: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
  author: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  text: z.ZodOptional<z.ZodString>;
  timestamp: z.ZodOptional<z.ZodInt>;
}, z.core.$strip>;
declare const zCastQuotesResponse: z.ZodObject<{
  result: z.ZodObject<{
    quotes: z.ZodOptional<z.ZodArray<z.ZodObject<{
      hash: z.ZodOptional<z.ZodString>;
      threadHash: z.ZodOptional<z.ZodString>;
      parentSource: z.ZodOptional<z.ZodObject<{
        type: z.ZodOptional<z.ZodString>;
        url: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      author: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      text: z.ZodOptional<z.ZodString>;
      timestamp: z.ZodOptional<z.ZodInt>;
    }, z.core.$strip>>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUserResponseUserResponse: z.ZodObject<{
  result: z.ZodObject<{
    user: z.ZodObject<{
      fid: z.ZodInt;
      username: z.ZodString;
      displayName: z.ZodString;
      pfp: z.ZodOptional<z.ZodObject<{
        url: z.ZodOptional<z.ZodURL>;
        verified: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      profile: z.ZodOptional<z.ZodObject<{
        bio: z.ZodOptional<z.ZodObject<{
          text: z.ZodOptional<z.ZodString>;
          mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        }, z.core.$strip>>;
        location: z.ZodOptional<z.ZodObject<{
          placeId: z.ZodOptional<z.ZodString>;
          description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      followerCount: z.ZodOptional<z.ZodInt>;
      followingCount: z.ZodOptional<z.ZodInt>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        followedBy: z.ZodOptional<z.ZodBoolean>;
        enableNotifications: z.ZodOptional<z.ZodBoolean>;
        canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
        hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSearchChannelsResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    channels: z.ZodOptional<z.ZodArray<z.ZodObject<{
      type: z.ZodOptional<z.ZodString>;
      key: z.ZodOptional<z.ZodString>;
      name: z.ZodOptional<z.ZodString>;
      imageUrl: z.ZodOptional<z.ZodString>;
      fastImageUrl: z.ZodOptional<z.ZodString>;
      feeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        type: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>>;
      description: z.ZodOptional<z.ZodString>;
      followerCount: z.ZodOptional<z.ZodInt>;
      memberCount: z.ZodOptional<z.ZodInt>;
      showCastSourceLabels: z.ZodOptional<z.ZodBoolean>;
      showCastTags: z.ZodOptional<z.ZodBoolean>;
      sectionRank: z.ZodOptional<z.ZodInt>;
      subscribable: z.ZodOptional<z.ZodBoolean>;
      publicCasting: z.ZodOptional<z.ZodBoolean>;
      inviteCode: z.ZodOptional<z.ZodString>;
      headerImageUrl: z.ZodOptional<z.ZodString>;
      headerAction: z.ZodOptional<z.ZodObject<{
        title: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      headerActionMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        following: z.ZodOptional<z.ZodBoolean>;
        isMember: z.ZodOptional<z.ZodBoolean>;
        hasUnseenItems: z.ZodOptional<z.ZodBoolean>;
        favoritePosition: z.ZodOptional<z.ZodInt>;
        activityRank: z.ZodOptional<z.ZodInt>;
        canCast: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zDraftsResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    drafts: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zDraftCast: z.ZodObject<{
  text: z.ZodOptional<z.ZodString>;
  embeds: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
}, z.core.$strip>;
declare const zDraft: z.ZodObject<{
  draftId: z.ZodOptional<z.ZodString>;
  casts: z.ZodOptional<z.ZodArray<z.ZodObject<{
    text: z.ZodOptional<z.ZodString>;
    embeds: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
  }, z.core.$strip>>>;
}, z.core.$strip>;
declare const zDraftCreatedResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    draft: z.ZodOptional<z.ZodObject<{
      draftId: z.ZodOptional<z.ZodString>;
      casts: z.ZodOptional<z.ZodArray<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        embeds: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zCastCreatedResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    cast: z.ZodOptional<z.ZodObject<{
      hash: z.ZodString;
      threadHash: z.ZodOptional<z.ZodString>;
      parentHash: z.ZodOptional<z.ZodString>;
      parentSource: z.ZodOptional<z.ZodObject<{
        type: z.ZodOptional<z.ZodEnum<{
          url: "url";
        }>>;
        url: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      author: z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      text: z.ZodString;
      timestamp: z.ZodCoercedBigInt<unknown>;
      mentions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>>;
      embeds: z.ZodOptional<z.ZodObject<{
        images: z.ZodOptional<z.ZodArray<z.ZodObject<{
          type: z.ZodOptional<z.ZodEnum<{
            image: "image";
          }>>;
          url: z.ZodOptional<z.ZodString>;
          sourceUrl: z.ZodOptional<z.ZodString>;
          media: z.ZodOptional<z.ZodObject<{
            version: z.ZodOptional<z.ZodString>;
            width: z.ZodOptional<z.ZodInt>;
            height: z.ZodOptional<z.ZodInt>;
            staticRaster: z.ZodOptional<z.ZodString>;
            mimeType: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
          alt: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        urls: z.ZodOptional<z.ZodArray<z.ZodObject<{
          type: z.ZodEnum<{
            url: "url";
          }>;
          openGraph: z.ZodObject<{
            url: z.ZodString;
            sourceUrl: z.ZodOptional<z.ZodString>;
            title: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
            domain: z.ZodOptional<z.ZodString>;
            image: z.ZodOptional<z.ZodString>;
            useLargeImage: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>;
        }, z.core.$strip>>>;
        videos: z.ZodOptional<z.ZodArray<z.ZodObject<{
          type: z.ZodOptional<z.ZodEnum<{
            video: "video";
          }>>;
        }, z.core.$strip>>>;
        unknowns: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
        processedCastText: z.ZodOptional<z.ZodString>;
        groupInvites: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
      }, z.core.$strip>>;
      replies: z.ZodObject<{
        count: z.ZodInt;
      }, z.core.$strip>;
      reactions: z.ZodObject<{
        count: z.ZodInt;
      }, z.core.$strip>;
      recasts: z.ZodObject<{
        count: z.ZodInt;
        recasters: z.ZodOptional<z.ZodArray<z.ZodObject<{
          fid: z.ZodOptional<z.ZodInt>;
          username: z.ZodOptional<z.ZodString>;
          displayName: z.ZodOptional<z.ZodString>;
          recastHash: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
      }, z.core.$strip>;
      watches: z.ZodObject<{
        count: z.ZodInt;
      }, z.core.$strip>;
      recast: z.ZodOptional<z.ZodBoolean>;
      tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodOptional<z.ZodString>;
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        imageUrl: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>>;
      quoteCount: z.ZodOptional<z.ZodInt>;
      combinedRecastCount: z.ZodOptional<z.ZodInt>;
      channel: z.ZodOptional<z.ZodObject<{
        key: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        imageUrl: z.ZodOptional<z.ZodString>;
        authorContext: z.ZodOptional<z.ZodObject<{
          role: z.ZodOptional<z.ZodString>;
          restricted: z.ZodOptional<z.ZodBoolean>;
          banned: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        authorRole: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      viewerContext: z.ZodOptional<z.ZodObject<{
        reacted: z.ZodOptional<z.ZodBoolean>;
        recast: z.ZodOptional<z.ZodBoolean>;
        bookmarked: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zRawChannel: z.ZodObject<{
  id: z.ZodOptional<z.ZodString>;
  url: z.ZodOptional<z.ZodString>;
  name: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
  descriptionMentions: z.ZodOptional<z.ZodArray<z.ZodInt>>;
  descriptionMentionsPositions: z.ZodOptional<z.ZodArray<z.ZodInt>>;
  imageUrl: z.ZodOptional<z.ZodString>;
  headerImageUrl: z.ZodOptional<z.ZodString>;
  leadFid: z.ZodOptional<z.ZodInt>;
  moderatorFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
  createdAt: z.ZodOptional<z.ZodInt>;
  followerCount: z.ZodOptional<z.ZodInt>;
  memberCount: z.ZodOptional<z.ZodInt>;
  pinnedCastHash: z.ZodOptional<z.ZodString>;
  publicCasting: z.ZodOptional<z.ZodBoolean>;
  externalLink: z.ZodOptional<z.ZodObject<{
    title: z.ZodOptional<z.ZodString>;
    url: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zChannelListResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    channels: z.ZodOptional<z.ZodArray<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      url: z.ZodOptional<z.ZodString>;
      name: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      descriptionMentions: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      descriptionMentionsPositions: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      imageUrl: z.ZodOptional<z.ZodString>;
      headerImageUrl: z.ZodOptional<z.ZodString>;
      leadFid: z.ZodOptional<z.ZodInt>;
      moderatorFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      createdAt: z.ZodOptional<z.ZodInt>;
      followerCount: z.ZodOptional<z.ZodInt>;
      memberCount: z.ZodOptional<z.ZodInt>;
      pinnedCastHash: z.ZodOptional<z.ZodString>;
      publicCasting: z.ZodOptional<z.ZodBoolean>;
      externalLink: z.ZodOptional<z.ZodObject<{
        title: z.ZodOptional<z.ZodString>;
        url: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zRawChannelResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    channel: z.ZodOptional<z.ZodObject<{
      id: z.ZodOptional<z.ZodString>;
      url: z.ZodOptional<z.ZodString>;
      name: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      descriptionMentions: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      descriptionMentionsPositions: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      imageUrl: z.ZodOptional<z.ZodString>;
      headerImageUrl: z.ZodOptional<z.ZodString>;
      leadFid: z.ZodOptional<z.ZodInt>;
      moderatorFids: z.ZodOptional<z.ZodArray<z.ZodInt>>;
      createdAt: z.ZodOptional<z.ZodInt>;
      followerCount: z.ZodOptional<z.ZodInt>;
      memberCount: z.ZodOptional<z.ZodInt>;
      pinnedCastHash: z.ZodOptional<z.ZodString>;
      publicCasting: z.ZodOptional<z.ZodBoolean>;
      externalLink: z.ZodOptional<z.ZodObject<{
        title: z.ZodOptional<z.ZodString>;
        url: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zChannelFollower: z.ZodObject<{
  fid: z.ZodOptional<z.ZodInt>;
  followedAt: z.ZodOptional<z.ZodInt>;
}, z.core.$strip>;
declare const zChannelFollowersResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
  next: z.ZodOptional<z.ZodObject<{
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    users: z.ZodOptional<z.ZodArray<z.ZodObject<{
      fid: z.ZodOptional<z.ZodInt>;
      followedAt: z.ZodOptional<z.ZodInt>;
    }, z.core.$strip>>>;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zChannelFollowStatus: z.ZodObject<{
  following: z.ZodOptional<z.ZodBoolean>;
  followedAt: z.ZodOptional<z.ZodInt>;
}, z.core.$strip>;
declare const zChannelFollowStatusResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    following: z.ZodOptional<z.ZodBoolean>;
    followedAt: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zAction: z.ZodObject<{
  name: z.ZodOptional<z.ZodString>;
  icon: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
  aboutUrl: z.ZodOptional<z.ZodURL>;
  imageUrl: z.ZodOptional<z.ZodURL>;
  actionUrl: z.ZodOptional<z.ZodURL>;
  action: z.ZodOptional<z.ZodObject<{
    actionType: z.ZodOptional<z.ZodEnum<{
      post: "post";
      get: "get";
      put: "put";
      delete: "delete";
    }>>;
    postUrl: z.ZodOptional<z.ZodURL>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zWinner: z.ZodObject<{
  fid: z.ZodOptional<z.ZodInt>;
  domain: z.ZodOptional<z.ZodString>;
  frameName: z.ZodOptional<z.ZodString>;
  score: z.ZodOptional<z.ZodInt>;
  rank: z.ZodOptional<z.ZodInt>;
  rewardCents: z.ZodOptional<z.ZodInt>;
  walletAddress: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const zFrame: z.ZodObject<{
  domain: z.ZodOptional<z.ZodString>;
  name: z.ZodOptional<z.ZodString>;
  iconUrl: z.ZodOptional<z.ZodString>;
  homeUrl: z.ZodOptional<z.ZodString>;
  splashImageUrl: z.ZodOptional<z.ZodString>;
  splashBackgroundColor: z.ZodOptional<z.ZodString>;
  buttonTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
  imageUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
  supportsNotifications: z.ZodOptional<z.ZodBoolean>;
  viewerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  author: z.ZodOptional<z.ZodObject<{
    fid: z.ZodInt;
    username: z.ZodString;
    displayName: z.ZodString;
    pfp: z.ZodOptional<z.ZodObject<{
      url: z.ZodOptional<z.ZodURL>;
      verified: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    profile: z.ZodOptional<z.ZodObject<{
      bio: z.ZodOptional<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>;
      location: z.ZodOptional<z.ZodObject<{
        placeId: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    followerCount: z.ZodOptional<z.ZodInt>;
    followingCount: z.ZodOptional<z.ZodInt>;
    viewerContext: z.ZodOptional<z.ZodObject<{
      following: z.ZodOptional<z.ZodBoolean>;
      followedBy: z.ZodOptional<z.ZodBoolean>;
      enableNotifications: z.ZodOptional<z.ZodBoolean>;
      canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
      hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zAppsByAuthorResponse: z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    frames: z.ZodOptional<z.ZodArray<z.ZodObject<{
      domain: z.ZodOptional<z.ZodString>;
      name: z.ZodOptional<z.ZodString>;
      iconUrl: z.ZodOptional<z.ZodString>;
      homeUrl: z.ZodOptional<z.ZodString>;
      splashImageUrl: z.ZodOptional<z.ZodString>;
      splashBackgroundColor: z.ZodOptional<z.ZodString>;
      buttonTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
      imageUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
      supportsNotifications: z.ZodOptional<z.ZodBoolean>;
      viewerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      author: z.ZodOptional<z.ZodObject<{
        fid: z.ZodInt;
        username: z.ZodString;
        displayName: z.ZodString;
        pfp: z.ZodOptional<z.ZodObject<{
          url: z.ZodOptional<z.ZodURL>;
          verified: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        profile: z.ZodOptional<z.ZodObject<{
          bio: z.ZodOptional<z.ZodObject<{
            text: z.ZodOptional<z.ZodString>;
            mentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
            channelMentions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
          }, z.core.$strip>>;
          location: z.ZodOptional<z.ZodObject<{
            placeId: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        followerCount: z.ZodOptional<z.ZodInt>;
        followingCount: z.ZodOptional<z.ZodInt>;
        viewerContext: z.ZodOptional<z.ZodObject<{
          following: z.ZodOptional<z.ZodBoolean>;
          followedBy: z.ZodOptional<z.ZodBoolean>;
          enableNotifications: z.ZodOptional<z.ZodBoolean>;
          canSendDirectCasts: z.ZodOptional<z.ZodBoolean>;
          hasUploadedInboxKeys: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
    }, z.core.$strip>>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zApiKey: z.ZodObject<{
  id: z.ZodUUID;
  createdAt: z.ZodCoercedBigInt<unknown>;
  expiresAt: z.ZodCoercedBigInt<unknown>;
  revokedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
  tag: z.ZodString;
  description: z.ZodString;
}, z.core.$strip>;
declare const zDirectCastSendResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    success: z.ZodBoolean;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zDirectCastConversationCategorizationResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    success: z.ZodBoolean;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zDirectCastConversationNotificationsResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    success: z.ZodBoolean;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zDirectCastConversationMessageTtlResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    success: z.ZodBoolean;
  }, z.core.$strip>>;
}, z.core.$strip>>;
declare const zDirectCastMessageReactionResponse: z.ZodIntersection<z.ZodObject<{
  result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>, z.ZodObject<{
  result: z.ZodOptional<z.ZodObject<{
    success: z.ZodBoolean;
  }, z.core.$strip>>;
}, z.core.$strip>>;
/**
 * The user's FID (Farcaster ID)
 */
declare const zFidParam: z.ZodInt;
/**
 * Maximum number of items to return
 */
declare const zLimitParam: z.ZodDefault<z.ZodInt>;
/**
 * Base64 encoded cursor for pagination
 */
declare const zCursorParam: z.ZodString;
declare const zGetUserOnboardingStateData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetUserByFidData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetDirectCastInboxData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    category: z.ZodOptional<z.ZodEnum<{
      default: "default";
      requests: "requests";
      spam: "spam";
    }>>;
    filter: z.ZodOptional<z.ZodEnum<{
      unread: "unread";
      group: "group";
      "1-1": "1-1";
    }>>;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetUserAppContextData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetUserPreferencesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetHighlightedChannelsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetFeedItemsData: z.ZodObject<{
  body: z.ZodObject<{
    feedKey: z.ZodString;
    feedType: z.ZodString;
    olderThan: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
    latestMainCastTimestamp: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
    excludeItemIdPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
    castViewEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
      ts: z.ZodOptional<z.ZodCoercedBigInt<unknown>>;
      hash: z.ZodOptional<z.ZodString>;
      on: z.ZodOptional<z.ZodString>;
      channel: z.ZodOptional<z.ZodString>;
      feed: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    updateState: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetUserData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetUserFollowingChannelsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    forComposer: z.ZodOptional<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetSuggestedUsersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    randomized: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetUserFavoriteFramesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetUserByUsernameData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    username: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelStreaksForUserData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetUnseenCountsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetUserThreadCastsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    castHashPrefix: z.ZodString;
    username: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelFollowersYouKnowData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelKey: z.ZodString;
    limit: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zMarkAllNotificationsReadData: z.ZodObject<{
  body: z.ZodRecord<z.ZodString, z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetNotificationsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    tab: z.ZodEnum<{
      mentions: "mentions";
      all: "all";
      follows: "follows";
      moderate: "moderate";
    }>;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSetLastCheckedTimestampData: z.ZodObject<{
  body: z.ZodRecord<z.ZodString, z.ZodUnknown>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetDirectCastConversationData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    conversationId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zCategorizeDirectCastConversationData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
    category: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetDirectCastConversationMessagesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    conversationId: z.ZodString;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSetDirectCastConversationMessageTtlData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
    ttl: z.ZodInt;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUpdateDirectCastConversationNotificationsData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
    muted: z.ZodBoolean;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetDirectCastConversationRecentMessagesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    conversationId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSendDirectCastMessageData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
    recipientFids: z.ZodArray<z.ZodInt>;
    messageId: z.ZodString;
    type: z.ZodEnum<{
      text: "text";
      reaction: "reaction";
      image: "image";
      link: "link";
    }>;
    message: z.ZodString;
    inReplyToId: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zDirectCastManuallyMarkUnreadData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zRemoveDirectCastMessageReactionData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
    messageId: z.ZodString;
    reaction: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zAddDirectCastMessageReactionData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
    messageId: z.ZodString;
    reaction: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUnpinDirectCastConversationData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zPinDirectCastConversationData: z.ZodObject<{
  body: z.ZodObject<{
    conversationId: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zDiscoverChannelsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetAvailableInvitesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetSponsoredInvitesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetOrCreateReferralCodeData: z.ZodObject<{
  body: z.ZodRecord<z.ZodString, z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetRewardsLeaderboardData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    rewardsType: z.ZodEnum<{
      invite: "invite";
    }>;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetUserRewardsScoresData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    rewardsType: z.ZodEnum<{
      invite: "invite";
    }>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetRewardsMetadataData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    rewardsType: z.ZodEnum<{
      invite: "invite";
    }>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetXpRewardsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetXpClaimableSummaryData: z.ZodObject<{
  body: z.ZodRecord<z.ZodString, z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetBookmarkedCastsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetUserStarterPacksData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetSuggestedStarterPacksData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetStarterPackData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    id: z.ZodUUID;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUpdateStarterPackData: z.ZodObject<{
  body: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodString;
    fids: z.ZodArray<z.ZodInt>;
    labels: z.ZodArray<z.ZodString>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
  headers: z.ZodOptional<z.ZodObject<{
    "Idempotency-Key": z.ZodOptional<z.ZodUUID>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetStarterPackUsersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    id: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    key: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelUsersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    channelKey: z.ZodString;
    filterToMembers: z.ZodOptional<z.ZodBoolean>;
    query: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetFollowingData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetFollowersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetMutualFollowersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetTopFrameAppsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetTopMiniAppsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetVerificationsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetMutedKeywordsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zMuteKeywordData: z.ZodObject<{
  body: z.ZodObject<{
    keyword: z.ZodOptional<z.ZodString>;
    properties: z.ZodOptional<z.ZodObject<{
      channels: z.ZodOptional<z.ZodBoolean>;
      frames: z.ZodOptional<z.ZodBoolean>;
      notifications: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUnmuteKeywordData: z.ZodObject<{
  body: z.ZodObject<{
    keyword: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUnlikeCastData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetCastLikesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    castHash: z.ZodString;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zLikeCastData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUndoRecastData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zRecastCastData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zAttachEmbedsData: z.ZodObject<{
  body: z.ZodObject<{
    text: z.ZodOptional<z.ZodString>;
    embeds: z.ZodOptional<z.ZodArray<z.ZodURL>>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetCastRecastersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    castHash: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetCastQuotesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    castHash: z.ZodString;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetCurrentUserData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zSearchChannelsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    q: z.ZodOptional<z.ZodString>;
    prioritizeFollowed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    forComposer: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetDraftCastsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zCreateDraftCastsData: z.ZodObject<{
  body: z.ZodObject<{
    caststorm: z.ZodOptional<z.ZodObject<{
      casts: z.ZodOptional<z.ZodArray<z.ZodObject<{
        text: z.ZodOptional<z.ZodString>;
        embeds: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
      }, z.core.$strip>>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
  headers: z.ZodObject<{
    "idempotency-key": z.ZodUUID;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zDeleteDraftCastData: z.ZodObject<{
  body: z.ZodObject<{
    draftId: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zDeleteCastData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetCastsByFidData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zCreateCastData: z.ZodObject<{
  body: z.ZodObject<{
    text: z.ZodString;
    embeds: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
    channelKey: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetAllChannelsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetChannelDetailsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelFollowersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetUserFollowedChannelsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zCheckUserChannelFollowStatusData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelMembersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zRemoveChannelInviteData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
    removeFid: z.ZodInt;
    role: z.ZodEnum<{
      member: "member";
      admin: "admin";
    }>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetChannelInvitesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zAcceptChannelInviteData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
    role: z.ZodEnum<{
      member: "member";
      admin: "admin";
    }>;
    accept: z.ZodBoolean;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zInviteUserToChannelData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
    inviteFid: z.ZodInt;
    role: z.ZodEnum<{
      member: "member";
      admin: "admin";
    }>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetChannelModeratedCastsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetChannelRestrictedUsersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUnbanUserFromChannelData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
    banFid: z.ZodInt;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetChannelBannedUsersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zBanUserFromChannelData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
    banFid: z.ZodInt;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUnfollowChannelData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zFollowChannelData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zModerateCastData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
    action: z.ZodEnum<{
      hide: "hide";
    }>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zUnpinCastFromChannelData: z.ZodObject<{
  body: z.ZodObject<{
    channelId: z.ZodString;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zPinCastToChannelData: z.ZodObject<{
  body: z.ZodObject<{
    castHash: z.ZodString;
    notifyChannelFollowers: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetDiscoverableActionsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    list: z.ZodString;
    limit: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetDiscoverableComposerActionsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    list: z.ZodString;
    limit: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zUnblockUserData: z.ZodObject<{
  body: z.ZodObject<{
    unblockFid: z.ZodInt;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetBlockedUsersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zBlockUserData: z.ZodObject<{
  body: z.ZodObject<{
    blockFid: z.ZodInt;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetAccountVerificationsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetCreatorRewardWinnersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    periodsAgo: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetUserPrimaryAddressData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    protocol: z.ZodEnum<{
      ethereum: "ethereum";
      solana: "solana";
    }>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetUserPrimaryAddressesData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fids: z.ZodString;
    protocol: z.ZodEnum<{
      ethereum: "ethereum";
      solana: "solana";
    }>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetStarterPackMembersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    id: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSendDirectCastData: z.ZodObject<{
  body: z.ZodObject<{
    recipientFid: z.ZodInt;
    message: z.ZodString;
    idempotencyKey: z.ZodUUID;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetUserByVerificationAddressData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    address: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetDeveloperRewardWinnersData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    periodsAgo: z.ZodOptional<z.ZodInt>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetAppsByAuthorData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetDomainManifestData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    domain: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetTrendingTopicsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetMetaTagsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    url: z.ZodURL;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetFarcasterJsonData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    domain: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetOwnedDomainsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetManagedAppsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetApiKeysData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zCreateApiKeyData: z.ZodObject<{
  body: z.ZodObject<{
    description: z.ZodString;
    expiresAt: z.ZodCoercedBigInt<unknown>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
  headers: z.ZodOptional<z.ZodObject<{
    "idempotency-key": z.ZodOptional<z.ZodUUID>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zRevokeApiKeyData: z.ZodObject<{
  body: z.ZodObject<{
    id: z.ZodUUID;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
  headers: z.ZodOptional<z.ZodObject<{
    "idempotency-key": z.ZodOptional<z.ZodUUID>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetConnectedAccountsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodObject<{
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>>;
}, z.core.$strip>;
declare const zGetProfileCastsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
    cursor: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zGetUserLikedCastsData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    fid: z.ZodInt;
    limit: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zSubmitAnalyticsEventsData: z.ZodObject<{
  body: z.ZodObject<{
    events: z.ZodArray<z.ZodObject<{
      type: z.ZodString;
      data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
      ts: z.ZodCoercedBigInt<unknown>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zGetMiniAppAnalyticsRollupData: z.ZodObject<{
  body: z.ZodObject<{
    dateRange: z.ZodObject<{
      startDate: z.ZodString;
      endDate: z.ZodString;
    }, z.core.$strip>;
    measures: z.ZodArray<z.ZodEnum<{
      miniapp_opens: "miniapp_opens";
      miniapp_transactions: "miniapp_transactions";
      miniapp_users_w_transaction: "miniapp_users_w_transaction";
      miniapp_users_w_open: "miniapp_users_w_open";
      miniapp_users_w_notifications_enabled: "miniapp_users_w_notifications_enabled";
      miniapp_users_w_notifications_disabled: "miniapp_users_w_notifications_disabled";
      miniapp_users_w_app_favorited: "miniapp_users_w_app_favorited";
      miniapp_users_w_app_unfavorited: "miniapp_users_w_app_unfavorited";
    }>>;
    restrictions: z.ZodArray<z.ZodObject<{
      dimension: z.ZodString;
      values: z.ZodArray<z.ZodString>;
    }, z.core.$strip>>;
    breakdownSettings: z.ZodOptional<z.ZodObject<{
      dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
      order: z.ZodOptional<z.ZodEnum<{
        asc: "asc";
        desc: "desc";
      }>>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
declare const zInspectMiniAppUrlData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    url: z.ZodURL;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zInspectImageUrlData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    url: z.ZodURL;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zExportMiniAppUserDataData: z.ZodObject<{
  body: z.ZodOptional<z.ZodNever>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodObject<{
    domain: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
declare const zRegisterStatsigEventsData: z.ZodObject<{
  body: z.ZodObject<{
    events: z.ZodArray<z.ZodObject<{
      eventName: z.ZodString;
      user: z.ZodObject<{
        userID: z.ZodOptional<z.ZodInt>;
        appVersion: z.ZodOptional<z.ZodString>;
        statsigEnvironment: z.ZodOptional<z.ZodObject<{
          tier: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
      }, z.core.$strip>;
      value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      time: z.ZodCoercedBigInt<unknown>;
      statsigMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      secondaryExposures: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    }, z.core.$strip>>;
    statsigMetadata: z.ZodOptional<z.ZodObject<{
      sdkType: z.ZodOptional<z.ZodString>;
      sdkVersion: z.ZodOptional<z.ZodString>;
      stableID: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>;
  path: z.ZodOptional<z.ZodNever>;
  query: z.ZodOptional<z.ZodNever>;
}, z.core.$strip>;
//#endregion
export { type AcceptChannelInviteData, type AcceptChannelInviteError, type AcceptChannelInviteErrors, type AcceptChannelInviteResponse, type AcceptChannelInviteResponses, type Action, ActionSchema, type AddDirectCastMessageReactionData, type AddDirectCastMessageReactionError, type AddDirectCastMessageReactionErrors, type AddDirectCastMessageReactionResponse, type AddDirectCastMessageReactionResponses, type ApiKey, ApiKeySchema, type AppsByAuthorResponse, AppsByAuthorResponseSchema, type AttachEmbedsData, type AttachEmbedsError, type AttachEmbedsErrors, type AttachEmbedsResponse, type AttachEmbedsResponse2, AttachEmbedsResponseSchema, type AttachEmbedsResponses, type Auth, type BadRequestError, BadRequestErrorSchema, type BanUserFromChannelData, type BanUserFromChannelError, type BanUserFromChannelErrors, type BanUserFromChannelResponse, type BanUserFromChannelResponses, type Bio, BioSchema, type BlockUserData, type BlockUserError, type BlockUserErrors, type BlockUserResponse, type BlockUserResponses, type BookmarkedCast, BookmarkedCastSchema, type BookmarkedCastsResponse, BookmarkedCastsResponseSchema, type Cast, type CastAction, CastActionSchema, type CastCreatedResponse, CastCreatedResponseSchema, type CastHashResponse, CastHashResponseSchema, type CastQuote, CastQuoteSchema, type CastQuotesResponse, CastQuotesResponseSchema, type CastRecastersResponse, CastRecastersResponseSchema, CastSchema, type CategorizeDirectCastConversationData, type CategorizeDirectCastConversationError, type CategorizeDirectCastConversationErrors, type CategorizeDirectCastConversationResponse, type CategorizeDirectCastConversationResponses, type Channel, type ChannelFollowStatus, type ChannelFollowStatusResponse, ChannelFollowStatusResponseSchema, ChannelFollowStatusSchema, type ChannelFollower, ChannelFollowerSchema, type ChannelFollowersResponse, ChannelFollowersResponseSchema, type ChannelFollowersYouKnowResponse, ChannelFollowersYouKnowResponseSchema, type ChannelListResponse, ChannelListResponseSchema, type ChannelResponse, ChannelResponseSchema, ChannelSchema, type ChannelStreaksResponse, ChannelStreaksResponseSchema, type ChannelUsersResponse, ChannelUsersResponseSchema, type CheckUserChannelFollowStatusData, type CheckUserChannelFollowStatusError, type CheckUserChannelFollowStatusErrors, type CheckUserChannelFollowStatusResponse, type CheckUserChannelFollowStatusResponses, type Client, type ClientOptions, type Config, type CreateApiKeyData, type CreateApiKeyError, type CreateApiKeyErrors, type CreateApiKeyResponse, type CreateApiKeyResponses, type CreateCastData, type CreateCastError, type CreateCastErrors, type CreateCastResponse, type CreateCastResponses, type CreateClientConfig, type CreateDraftCastsData, type CreateDraftCastsError, type CreateDraftCastsErrors, type CreateDraftCastsResponse, type CreateDraftCastsResponses, type CursorParam, type DeleteCastData, type DeleteCastError, type DeleteCastErrors, type DeleteCastResponse, type DeleteCastResponses, type DeleteDraftCastData, type DeleteDraftCastError, type DeleteDraftCastErrors, type DeleteDraftCastResponse, type DeleteDraftCastResponses, type DirectCastConversation, type DirectCastConversationCategorizationRequest, DirectCastConversationCategorizationRequestSchema, type DirectCastConversationCategorizationResponse, DirectCastConversationCategorizationResponseSchema, type DirectCastConversationMessageTtlRequest, DirectCastConversationMessageTtlRequestSchema, type DirectCastConversationMessageTtlResponse, DirectCastConversationMessageTtlResponseSchema, type DirectCastConversationMessagesResponse, DirectCastConversationMessagesResponseSchema, type DirectCastConversationNotificationsRequest, DirectCastConversationNotificationsRequestSchema, type DirectCastConversationNotificationsResponse, DirectCastConversationNotificationsResponseSchema, type DirectCastConversationResponse, DirectCastConversationResponseSchema, DirectCastConversationSchema, type DirectCastConversationViewerContext, DirectCastConversationViewerContextSchema, type DirectCastInboxResponse, DirectCastInboxResponseSchema, type DirectCastInboxResult, DirectCastInboxResultSchema, type DirectCastManuallyMarkUnreadData, type DirectCastManuallyMarkUnreadError, type DirectCastManuallyMarkUnreadErrors, type DirectCastManuallyMarkUnreadRequest, DirectCastManuallyMarkUnreadRequestSchema, type DirectCastManuallyMarkUnreadResponse, type DirectCastManuallyMarkUnreadResponses, type DirectCastMessage, type DirectCastMessageMention, DirectCastMessageMentionSchema, type DirectCastMessageMetadata, DirectCastMessageMetadataSchema, type DirectCastMessageReaction, type DirectCastMessageReactionRequest, DirectCastMessageReactionRequestSchema, type DirectCastMessageReactionResponse, DirectCastMessageReactionResponseSchema, DirectCastMessageReactionSchema, DirectCastMessageSchema, type DirectCastMessageViewerContext, DirectCastMessageViewerContextSchema, type DirectCastPinConversationRequest, DirectCastPinConversationRequestSchema, type DirectCastSendRequest, DirectCastSendRequestSchema, type DirectCastSendResponse, DirectCastSendResponseSchema, type DiscoverChannelsData, type DiscoverChannelsError, type DiscoverChannelsErrors, type DiscoverChannelsResponse, type DiscoverChannelsResponse2, DiscoverChannelsResponseSchema, type DiscoverChannelsResponses, type Draft, type DraftCast, DraftCastSchema, type DraftCreatedResponse, DraftCreatedResponseSchema, DraftSchema, type DraftsResponse, DraftsResponseSchema, type ErrorResponse, ErrorResponseSchema, type ExportMiniAppUserDataData, type ExportMiniAppUserDataError, type ExportMiniAppUserDataErrors, type ExportMiniAppUserDataResponse, type ExportMiniAppUserDataResponses, type FavoriteFramesResponse, FavoriteFramesResponseSchema, type FeedItemsResponse, FeedItemsResponseSchema, type FidParam, type FollowChannelData, type FollowChannelError, type FollowChannelErrors, type FollowChannelResponse, type FollowChannelResponses, type Frame, type FrameApp, FrameAppSchema, type FrameAppsResponse, FrameAppsResponseSchema, FrameSchema, type GenericBadRequestError, GenericBadRequestErrorSchema, type GenericResponse, GenericResponseSchema, type GetAccountVerificationsData, type GetAccountVerificationsError, type GetAccountVerificationsErrors, type GetAccountVerificationsResponse, type GetAccountVerificationsResponses, type GetAllChannelsData, type GetAllChannelsError, type GetAllChannelsErrors, type GetAllChannelsResponse, type GetAllChannelsResponses, type GetApiKeysData, type GetApiKeysError, type GetApiKeysErrors, type GetApiKeysResponse, type GetApiKeysResponses, type GetAppsByAuthorData, type GetAppsByAuthorError, type GetAppsByAuthorErrors, type GetAppsByAuthorResponse, type GetAppsByAuthorResponses, type GetAvailableInvitesData, type GetAvailableInvitesError, type GetAvailableInvitesErrors, type GetAvailableInvitesResponse, type GetAvailableInvitesResponses, type GetBlockedUsersData, type GetBlockedUsersError, type GetBlockedUsersErrors, type GetBlockedUsersResponse, type GetBlockedUsersResponses, type GetBookmarkedCastsData, type GetBookmarkedCastsError, type GetBookmarkedCastsErrors, type GetBookmarkedCastsResponse, type GetBookmarkedCastsResponses, type GetCastLikesData, type GetCastLikesError, type GetCastLikesErrors, type GetCastLikesResponse, type GetCastLikesResponses, type GetCastQuotesData, type GetCastQuotesError, type GetCastQuotesErrors, type GetCastQuotesResponse, type GetCastQuotesResponses, type GetCastRecastersData, type GetCastRecastersError, type GetCastRecastersErrors, type GetCastRecastersResponse, type GetCastRecastersResponses, type GetCastsByFidData, type GetCastsByFidError, type GetCastsByFidErrors, type GetCastsByFidResponse, type GetCastsByFidResponses, type GetChannelBannedUsersData, type GetChannelBannedUsersError, type GetChannelBannedUsersErrors, type GetChannelBannedUsersResponse, type GetChannelBannedUsersResponses, type GetChannelData, type GetChannelDetailsData, type GetChannelDetailsError, type GetChannelDetailsErrors, type GetChannelDetailsResponse, type GetChannelDetailsResponses, type GetChannelError, type GetChannelErrors, type GetChannelFollowersData, type GetChannelFollowersError, type GetChannelFollowersErrors, type GetChannelFollowersResponse, type GetChannelFollowersResponses, type GetChannelFollowersYouKnowData, type GetChannelFollowersYouKnowError, type GetChannelFollowersYouKnowErrors, type GetChannelFollowersYouKnowResponse, type GetChannelFollowersYouKnowResponses, type GetChannelInvitesData, type GetChannelInvitesError, type GetChannelInvitesErrors, type GetChannelInvitesResponse, type GetChannelInvitesResponses, type GetChannelMembersData, type GetChannelMembersError, type GetChannelMembersErrors, type GetChannelMembersResponse, type GetChannelMembersResponses, type GetChannelModeratedCastsData, type GetChannelModeratedCastsError, type GetChannelModeratedCastsErrors, type GetChannelModeratedCastsResponse, type GetChannelModeratedCastsResponses, type GetChannelResponse, type GetChannelResponses, type GetChannelRestrictedUsersData, type GetChannelRestrictedUsersError, type GetChannelRestrictedUsersErrors, type GetChannelRestrictedUsersResponse, type GetChannelRestrictedUsersResponses, type GetChannelStreaksForUserData, type GetChannelStreaksForUserError, type GetChannelStreaksForUserErrors, type GetChannelStreaksForUserResponse, type GetChannelStreaksForUserResponses, type GetChannelUsersData, type GetChannelUsersError, type GetChannelUsersErrors, type GetChannelUsersResponse, type GetChannelUsersResponses, type GetConnectedAccountsData, type GetConnectedAccountsError, type GetConnectedAccountsErrors, type GetConnectedAccountsResponse, type GetConnectedAccountsResponses, type GetCreatorRewardWinnersData, type GetCreatorRewardWinnersError, type GetCreatorRewardWinnersErrors, type GetCreatorRewardWinnersResponse, type GetCreatorRewardWinnersResponses, type GetCurrentUserData, type GetCurrentUserError, type GetCurrentUserErrors, type GetCurrentUserResponse, type GetCurrentUserResponses, type GetDeveloperRewardWinnersData, type GetDeveloperRewardWinnersError, type GetDeveloperRewardWinnersErrors, type GetDeveloperRewardWinnersResponse, type GetDeveloperRewardWinnersResponses, type GetDirectCastConversationData, type GetDirectCastConversationError, type GetDirectCastConversationErrors, type GetDirectCastConversationMessagesData, type GetDirectCastConversationMessagesError, type GetDirectCastConversationMessagesErrors, type GetDirectCastConversationMessagesResponse, type GetDirectCastConversationMessagesResponses, type GetDirectCastConversationRecentMessagesData, type GetDirectCastConversationRecentMessagesError, type GetDirectCastConversationRecentMessagesErrors, type GetDirectCastConversationRecentMessagesResponse, type GetDirectCastConversationRecentMessagesResponses, type GetDirectCastConversationResponse, type GetDirectCastConversationResponses, type GetDirectCastInboxData, type GetDirectCastInboxError, type GetDirectCastInboxErrors, type GetDirectCastInboxResponse, type GetDirectCastInboxResponses, type GetDiscoverableActionsData, type GetDiscoverableActionsError, type GetDiscoverableActionsErrors, type GetDiscoverableActionsResponse, type GetDiscoverableActionsResponses, type GetDiscoverableComposerActionsData, type GetDiscoverableComposerActionsError, type GetDiscoverableComposerActionsErrors, type GetDiscoverableComposerActionsResponse, type GetDiscoverableComposerActionsResponses, type GetDomainManifestData, type GetDomainManifestError, type GetDomainManifestErrors, type GetDomainManifestResponse, type GetDomainManifestResponses, type GetDraftCastsData, type GetDraftCastsError, type GetDraftCastsErrors, type GetDraftCastsResponse, type GetDraftCastsResponses, type GetFarcasterJsonData, type GetFarcasterJsonError, type GetFarcasterJsonErrors, type GetFarcasterJsonResponse, type GetFarcasterJsonResponses, type GetFeedItemsData, type GetFeedItemsError, type GetFeedItemsErrors, type GetFeedItemsResponse, type GetFeedItemsResponses, type GetFollowersData, type GetFollowersError, type GetFollowersErrors, type GetFollowersResponse, type GetFollowersResponses, type GetFollowingData, type GetFollowingError, type GetFollowingErrors, type GetFollowingResponse, type GetFollowingResponses, type GetHighlightedChannelsData, type GetHighlightedChannelsError, type GetHighlightedChannelsErrors, type GetHighlightedChannelsResponse, type GetHighlightedChannelsResponses, type GetManagedAppsData, type GetManagedAppsError, type GetManagedAppsErrors, type GetManagedAppsResponse, type GetManagedAppsResponses, type GetMetaTagsData, type GetMetaTagsError, type GetMetaTagsErrors, type GetMetaTagsResponse, type GetMetaTagsResponses, type GetMiniAppAnalyticsRollupData, type GetMiniAppAnalyticsRollupError, type GetMiniAppAnalyticsRollupErrors, type GetMiniAppAnalyticsRollupResponse, type GetMiniAppAnalyticsRollupResponses, type GetMutedKeywordsData, type GetMutedKeywordsError, type GetMutedKeywordsErrors, type GetMutedKeywordsResponse, type GetMutedKeywordsResponses, type GetMutualFollowersData, type GetMutualFollowersError, type GetMutualFollowersErrors, type GetMutualFollowersResponse, type GetMutualFollowersResponses, type GetNotificationsData, type GetNotificationsError, type GetNotificationsErrors, type GetNotificationsResponse, type GetNotificationsResponses, type GetOrCreateReferralCodeData, type GetOrCreateReferralCodeError, type GetOrCreateReferralCodeErrors, type GetOrCreateReferralCodeResponse, type GetOrCreateReferralCodeResponses, type GetOwnedDomainsData, type GetOwnedDomainsError, type GetOwnedDomainsErrors, type GetOwnedDomainsResponse, type GetOwnedDomainsResponses, type GetProfileCastsData, type GetProfileCastsError, type GetProfileCastsErrors, type GetProfileCastsResponse, type GetProfileCastsResponses, type GetRewardsLeaderboardData, type GetRewardsLeaderboardError, type GetRewardsLeaderboardErrors, type GetRewardsLeaderboardResponse, type GetRewardsLeaderboardResponses, type GetRewardsMetadataData, type GetRewardsMetadataError, type GetRewardsMetadataErrors, type GetRewardsMetadataResponse, type GetRewardsMetadataResponses, type GetSponsoredInvitesData, type GetSponsoredInvitesError, type GetSponsoredInvitesErrors, type GetSponsoredInvitesResponse, type GetSponsoredInvitesResponses, type GetStarterPackData, type GetStarterPackError, type GetStarterPackErrors, type GetStarterPackMembersData, type GetStarterPackMembersError, type GetStarterPackMembersErrors, type GetStarterPackMembersResponse, type GetStarterPackMembersResponses, type GetStarterPackResponse, type GetStarterPackResponses, type GetStarterPackUsersData, type GetStarterPackUsersError, type GetStarterPackUsersErrors, type GetStarterPackUsersResponse, type GetStarterPackUsersResponses, type GetSuggestedStarterPacksData, type GetSuggestedStarterPacksError, type GetSuggestedStarterPacksErrors, type GetSuggestedStarterPacksResponse, type GetSuggestedStarterPacksResponses, type GetSuggestedUsersData, type GetSuggestedUsersError, type GetSuggestedUsersErrors, type GetSuggestedUsersResponse, type GetSuggestedUsersResponses, type GetTopFrameAppsData, type GetTopFrameAppsError, type GetTopFrameAppsErrors, type GetTopFrameAppsResponse, type GetTopFrameAppsResponses, type GetTopMiniAppsData, type GetTopMiniAppsError, type GetTopMiniAppsErrors, type GetTopMiniAppsResponse, type GetTopMiniAppsResponses, type GetTrendingTopicsData, type GetTrendingTopicsError, type GetTrendingTopicsErrors, type GetTrendingTopicsResponse, type GetTrendingTopicsResponses, type GetUnseenCountsData, type GetUnseenCountsError, type GetUnseenCountsErrors, type GetUnseenCountsResponse, type GetUnseenCountsResponses, type GetUserAppContextData, type GetUserAppContextError, type GetUserAppContextErrors, type GetUserAppContextResponse, type GetUserAppContextResponses, type GetUserByFidData, type GetUserByFidError, type GetUserByFidErrors, type GetUserByFidResponse, type GetUserByFidResponses, type GetUserByUsernameData, type GetUserByUsernameError, type GetUserByUsernameErrors, type GetUserByUsernameResponse, type GetUserByUsernameResponses, type GetUserByVerificationAddressData, type GetUserByVerificationAddressError, type GetUserByVerificationAddressErrors, type GetUserByVerificationAddressResponse, type GetUserByVerificationAddressResponses, type GetUserData, type GetUserError, type GetUserErrors, type GetUserFavoriteFramesData, type GetUserFavoriteFramesError, type GetUserFavoriteFramesErrors, type GetUserFavoriteFramesResponse, type GetUserFavoriteFramesResponses, type GetUserFollowedChannelsData, type GetUserFollowedChannelsError, type GetUserFollowedChannelsErrors, type GetUserFollowedChannelsResponse, type GetUserFollowedChannelsResponses, type GetUserFollowingChannelsData, type GetUserFollowingChannelsError, type GetUserFollowingChannelsErrors, type GetUserFollowingChannelsResponse, type GetUserFollowingChannelsResponses, type GetUserLikedCastsData, type GetUserLikedCastsError, type GetUserLikedCastsErrors, type GetUserLikedCastsResponse, type GetUserLikedCastsResponses, type GetUserOnboardingStateData, type GetUserOnboardingStateError, type GetUserOnboardingStateErrors, type GetUserOnboardingStateResponse, type GetUserOnboardingStateResponses, type GetUserPreferencesData, type GetUserPreferencesError, type GetUserPreferencesErrors, type GetUserPreferencesResponse, type GetUserPreferencesResponses, type GetUserPrimaryAddressData, type GetUserPrimaryAddressError, type GetUserPrimaryAddressErrors, type GetUserPrimaryAddressResponse, type GetUserPrimaryAddressResponses, type GetUserPrimaryAddressesData, type GetUserPrimaryAddressesError, type GetUserPrimaryAddressesErrors, type GetUserPrimaryAddressesResponse, type GetUserPrimaryAddressesResponses, type GetUserResponse, type GetUserResponses, type GetUserRewardsScoresData, type GetUserRewardsScoresError, type GetUserRewardsScoresErrors, type GetUserRewardsScoresResponse, type GetUserRewardsScoresResponses, type GetUserStarterPacksData, type GetUserStarterPacksError, type GetUserStarterPacksErrors, type GetUserStarterPacksResponse, type GetUserStarterPacksResponses, type GetUserThreadCastsData, type GetUserThreadCastsError, type GetUserThreadCastsErrors, type GetUserThreadCastsResponse, type GetUserThreadCastsResponses, type GetVerificationsData, type GetVerificationsError, type GetVerificationsErrors, type GetVerificationsResponse, type GetVerificationsResponses, type GetXpClaimableSummaryData, type GetXpClaimableSummaryError, type GetXpClaimableSummaryErrors, type GetXpClaimableSummaryResponse, type GetXpClaimableSummaryResponses, type GetXpRewardsData, type GetXpRewardsError, type GetXpRewardsErrors, type GetXpRewardsResponse, type GetXpRewardsResponses, type HighlightedChannelsResponse, HighlightedChannelsResponseSchema, type ImageEmbed, ImageEmbedSchema, type InspectImageUrlData, type InspectImageUrlError, type InspectImageUrlErrors, type InspectImageUrlResponse, type InspectImageUrlResponses, type InspectMiniAppUrlData, type InspectMiniAppUrlError, type InspectMiniAppUrlErrors, type InspectMiniAppUrlResponse, type InspectMiniAppUrlResponses, type InviteUserToChannelData, type InviteUserToChannelError, type InviteUserToChannelErrors, type InviteUserToChannelResponse, type InviteUserToChannelResponses, type InvitesAvailableResponse, InvitesAvailableResponseSchema, type LikeCastData, type LikeCastError, type LikeCastErrors, type LikeCastResponse, type LikeCastResponses, type LimitParam, type Location, LocationSchema, type MarkAllNotificationsReadData, type MarkAllNotificationsReadError, type MarkAllNotificationsReadErrors, type MarkAllNotificationsReadResponse, type MarkAllNotificationsReadResponses, type MiniApp, MiniAppSchema, type MiniAppViewerContext, type ModerateCastData, type ModerateCastError, type ModerateCastErrors, type ModerateCastResponse, type ModerateCastResponses, type MuteKeywordData, type MuteKeywordError, type MuteKeywordErrors, type MuteKeywordResponse, type MuteKeywordResponses, type MutedKeyword, type MutedKeywordProperties, MutedKeywordPropertiesSchema, MutedKeywordSchema, type MutedKeywordsResponse, MutedKeywordsResponseSchema, type NotificationsResponse, NotificationsResponseSchema, type OnboardingState, type OnboardingStateResponse, OnboardingStateResponseSchema, OnboardingStateSchema, type Options, type PaginatedResponse, PaginatedResponseSchema, type PaginationCursor, PaginationCursorSchema, type PinCastToChannelData, type PinCastToChannelError, type PinCastToChannelErrors, type PinCastToChannelResponse, type PinCastToChannelResponses, type PinDirectCastConversationData, type PinDirectCastConversationError, type PinDirectCastConversationErrors, type PinDirectCastConversationResponse, type PinDirectCastConversationResponses, type Profile, type ProfilePicture, ProfilePictureSchema, ProfileSchema, type QuerySerializerOptions, type RankedMiniApp, RankedMiniAppSchema, type RawChannel, type RawChannelResponse, RawChannelResponseSchema, RawChannelSchema, type RecastCastData, type RecastCastError, type RecastCastErrors, type RecastCastResponse, type RecastCastResponses, type Recaster, RecasterSchema, type RegisterStatsigEventsData, type RegisterStatsigEventsError, type RegisterStatsigEventsErrors, type RegisterStatsigEventsResponse, type RegisterStatsigEventsResponses, type RemoveChannelInviteData, type RemoveChannelInviteError, type RemoveChannelInviteErrors, type RemoveChannelInviteResponse, type RemoveChannelInviteResponses, type RemoveDirectCastMessageReactionData, type RemoveDirectCastMessageReactionError, type RemoveDirectCastMessageReactionErrors, type RemoveDirectCastMessageReactionResponse, type RemoveDirectCastMessageReactionResponses, type RequestOptions, type RequestResult, type ResolvedRequestOptions, type ResponseStyle, type RevokeApiKeyData, type RevokeApiKeyError, type RevokeApiKeyErrors, type RevokeApiKeyResponse, type RevokeApiKeyResponses, type RewardsLeaderboardResponse, RewardsLeaderboardResponseSchema, type RewardsMetadataResponse, RewardsMetadataResponseSchema, type RewardsScoresResponse, RewardsScoresResponseSchema, type SearchChannelsData, type SearchChannelsError, type SearchChannelsErrors, type SearchChannelsResponse, type SearchChannelsResponse2, SearchChannelsResponseSchema, type SearchChannelsResponses, type SendDirectCastData, type SendDirectCastError, type SendDirectCastErrors, type SendDirectCastMessageData, type SendDirectCastMessageError, type SendDirectCastMessageErrors, type SendDirectCastMessageResponse, type SendDirectCastMessageResponses, type SendDirectCastResponse, type SendDirectCastResponses, type SetDirectCastConversationMessageTtlData, type SetDirectCastConversationMessageTtlError, type SetDirectCastConversationMessageTtlErrors, type SetDirectCastConversationMessageTtlResponse, type SetDirectCastConversationMessageTtlResponses, type SetLastCheckedTimestampData, type SetLastCheckedTimestampError, type SetLastCheckedTimestampErrors, type SetLastCheckedTimestampResponse, type SetLastCheckedTimestampResponses, type SponsoredInvitesResponse, SponsoredInvitesResponseSchema, type StarterPack, type StarterPackResponse, StarterPackResponseSchema, StarterPackSchema, type StarterPackUpdateRequest, StarterPackUpdateRequestSchema, type StarterPackUsersResponse, StarterPackUsersResponseSchema, type StarterPacksResponse, StarterPacksResponseSchema, type SubmitAnalyticsEventsData, type SubmitAnalyticsEventsError, type SubmitAnalyticsEventsErrors, type SubmitAnalyticsEventsResponse, type SubmitAnalyticsEventsResponses, type SuccessResponse, SuccessResponseSchema, type SuggestedUsersResponse, SuggestedUsersResponseSchema, type TDataShape, type TopMiniAppsResponse, TopMiniAppsResponseSchema, type UnbanUserFromChannelData, type UnbanUserFromChannelError, type UnbanUserFromChannelErrors, type UnbanUserFromChannelResponse, type UnbanUserFromChannelResponses, type UnblockUserData, type UnblockUserError, type UnblockUserErrors, type UnblockUserResponse, type UnblockUserResponses, type UndoRecastData, type UndoRecastError, type UndoRecastErrors, type UndoRecastResponse, type UndoRecastResponses, type UnfollowChannelData, type UnfollowChannelError, type UnfollowChannelErrors, type UnfollowChannelResponse, type UnfollowChannelResponses, type UnlikeCastData, type UnlikeCastError, type UnlikeCastErrors, type UnlikeCastResponse, type UnlikeCastResponses, type UnmuteKeywordData, type UnmuteKeywordError, type UnmuteKeywordErrors, type UnmuteKeywordResponse, type UnmuteKeywordResponses, type UnpinCastFromChannelData, type UnpinCastFromChannelError, type UnpinCastFromChannelErrors, type UnpinCastFromChannelResponse, type UnpinCastFromChannelResponses, type UnpinDirectCastConversationData, type UnpinDirectCastConversationError, type UnpinDirectCastConversationErrors, type UnpinDirectCastConversationResponse, type UnpinDirectCastConversationResponses, type UnseenCountsResponse, UnseenCountsResponseSchema, type UpdateDirectCastConversationNotificationsData, type UpdateDirectCastConversationNotificationsError, type UpdateDirectCastConversationNotificationsErrors, type UpdateDirectCastConversationNotificationsResponse, type UpdateDirectCastConversationNotificationsResponses, type UpdateStarterPackData, type UpdateStarterPackError, type UpdateStarterPackErrors, type UpdateStarterPackResponse, type UpdateStarterPackResponses, type UrlEmbed, UrlEmbedSchema, type User, type UserAppContextResponse, UserAppContextResponseSchema, type UserByFidResponse, UserByFidResponseSchema, type UserExtras, UserExtrasSchema, type UserPreferencesResponse, UserPreferencesResponseSchema, type UserResponse, UserResponseSchema, type UserResponseUserResponse, UserSchema, type UserThreadCastsResponse, UserThreadCastsResponseSchema, type UserWithExtras, UserWithExtrasSchema, type UsersResponse, UsersResponseSchema, type UsersWithCountResponse, UsersWithCountResponseSchema, type ValidationError, ValidationErrorSchema, type VerifiedAddress, VerifiedAddressSchema, type VideoEmbed, VideoEmbedSchema, type ViewerContext, ViewerContextSchema, type Winner, WinnerSchema, acceptChannelInvite, addDirectCastMessageReaction, attachEmbeds, banUserFromChannel, blockUser, buildClientParams, categorizeDirectCastConversation, checkUserChannelFollowStatus, client, createApiKey, createCast, createCastResponseTransformer, createClient, createConfig, createDraftCasts, deleteCast, deleteDraftCast, directCastManuallyMarkUnread, discoverChannels, exportMiniAppUserData, followChannel, formDataBodySerializer, getAccountVerifications, getAllChannels, getApiKeys, getApiKeysResponseTransformer, getAppsByAuthor, getAvailableInvites, getBlockedUsers, getBookmarkedCasts, getCastLikes, getCastQuotes, getCastRecasters, getCastsByFid, getCastsByFidResponseTransformer, getChannel, getChannelBannedUsers, getChannelDetails, getChannelFollowers, getChannelFollowersYouKnow, getChannelInvites, getChannelMembers, getChannelModeratedCasts, getChannelRestrictedUsers, getChannelStreaksForUser, getChannelUsers, getConnectedAccounts, getCreatorRewardWinners, getCreatorRewardWinnersResponseTransformer, getCurrentUser, getDeveloperRewardWinners, getDirectCastConversation, getDirectCastConversationMessages, getDirectCastConversationMessagesResponseTransformer, getDirectCastConversationRecentMessages, getDirectCastConversationRecentMessagesResponseTransformer, getDirectCastConversationResponseTransformer, getDirectCastInbox, getDirectCastInboxResponseTransformer, getDiscoverableActions, getDiscoverableComposerActions, getDomainManifest, getDraftCasts, getFarcasterJson, getFeedItems, getFeedItemsResponseTransformer, getFollowers, getFollowing, getHighlightedChannels, getManagedApps, getMetaTags, getMiniAppAnalyticsRollup, getMiniAppAnalyticsRollupResponseTransformer, getMutedKeywords, getMutualFollowers, getNotifications, getOrCreateReferralCode, getOwnedDomains, getProfileCasts, getProfileCastsResponseTransformer, getRewardsLeaderboard, getRewardsMetadata, getRewardsMetadataResponseTransformer, getSponsoredInvites, getStarterPack, getStarterPackMembers, getStarterPackMembersResponseTransformer, getStarterPackUsers, getSuggestedStarterPacks, getSuggestedUsers, getTopFrameApps, getTopMiniApps, getTrendingTopics, getUnseenCounts, getUser, getUserAppContext, getUserByFid, getUserByUsername, getUserByVerificationAddress, getUserFavoriteFrames, getUserFollowedChannels, getUserFollowingChannels, getUserLikedCasts, getUserLikedCastsResponseTransformer, getUserOnboardingState, getUserPreferences, getUserPrimaryAddress, getUserPrimaryAddresses, getUserRewardsScores, getUserStarterPacks, getUserThreadCasts, getVerifications, getXpClaimableSummary, getXpRewards, inspectImageUrl, inspectMiniAppUrl, inviteUserToChannel, jsonBodySerializer, likeCast, markAllNotificationsRead, mergeHeaders, mini_app_ViewerContextSchema, moderateCast, muteKeyword, pinCastToChannel, pinDirectCastConversation, recastCast, registerStatsigEvents, removeChannelInvite, removeDirectCastMessageReaction, revokeApiKey, searchChannels, sendDirectCast, sendDirectCastMessage, serializeQueryKeyValue, setDirectCastConversationMessageTtl, setLastCheckedTimestamp, submitAnalyticsEvents, unbanUserFromChannel, unblockUser, undoRecast, unfollowChannel, unlikeCast, unmuteKeyword, unpinCastFromChannel, unpinDirectCastConversation, updateDirectCastConversationNotifications, updateStarterPack, urlSearchParamsBodySerializer, user_response_UserResponseSchema, version, zAcceptChannelInviteData, zAction, zAddDirectCastMessageReactionData, zApiKey, zAppsByAuthorResponse, zAttachEmbedsData, zAttachEmbedsResponse, zBadRequestError, zBanUserFromChannelData, zBio, zBlockUserData, zBookmarkedCast, zBookmarkedCastsResponse, zCast, zCastAction, zCastCreatedResponse, zCastHashResponse, zCastQuote, zCastQuotesResponse, zCastRecastersResponse, zCategorizeDirectCastConversationData, zChannel, zChannelFollowStatus, zChannelFollowStatusResponse, zChannelFollower, zChannelFollowersResponse, zChannelFollowersYouKnowResponse, zChannelListResponse, zChannelResponse, zChannelStreaksResponse, zChannelUsersResponse, zCheckUserChannelFollowStatusData, zCreateApiKeyData, zCreateCastData, zCreateDraftCastsData, zCursorParam, zDeleteCastData, zDeleteDraftCastData, zDirectCastConversation, zDirectCastConversationCategorizationRequest, zDirectCastConversationCategorizationResponse, zDirectCastConversationMessageTtlRequest, zDirectCastConversationMessageTtlResponse, zDirectCastConversationMessagesResponse, zDirectCastConversationNotificationsRequest, zDirectCastConversationNotificationsResponse, zDirectCastConversationResponse, zDirectCastConversationViewerContext, zDirectCastInboxResponse, zDirectCastInboxResult, zDirectCastManuallyMarkUnreadData, zDirectCastManuallyMarkUnreadRequest, zDirectCastMessage, zDirectCastMessageMention, zDirectCastMessageMetadata, zDirectCastMessageReaction, zDirectCastMessageReactionRequest, zDirectCastMessageReactionResponse, zDirectCastMessageViewerContext, zDirectCastPinConversationRequest, zDirectCastSendRequest, zDirectCastSendResponse, zDiscoverChannelsData, zDiscoverChannelsResponse, zDraft, zDraftCast, zDraftCreatedResponse, zDraftsResponse, zErrorResponse, zExportMiniAppUserDataData, zFavoriteFramesResponse, zFeedItemsResponse, zFidParam, zFollowChannelData, zFrame, zFrameApp, zFrameAppsResponse, zGenericBadRequestError, zGenericResponse, zGetAccountVerificationsData, zGetAllChannelsData, zGetApiKeysData, zGetAppsByAuthorData, zGetAvailableInvitesData, zGetBlockedUsersData, zGetBookmarkedCastsData, zGetCastLikesData, zGetCastQuotesData, zGetCastRecastersData, zGetCastsByFidData, zGetChannelBannedUsersData, zGetChannelData, zGetChannelDetailsData, zGetChannelFollowersData, zGetChannelFollowersYouKnowData, zGetChannelInvitesData, zGetChannelMembersData, zGetChannelModeratedCastsData, zGetChannelRestrictedUsersData, zGetChannelStreaksForUserData, zGetChannelUsersData, zGetConnectedAccountsData, zGetCreatorRewardWinnersData, zGetCurrentUserData, zGetDeveloperRewardWinnersData, zGetDirectCastConversationData, zGetDirectCastConversationMessagesData, zGetDirectCastConversationRecentMessagesData, zGetDirectCastInboxData, zGetDiscoverableActionsData, zGetDiscoverableComposerActionsData, zGetDomainManifestData, zGetDraftCastsData, zGetFarcasterJsonData, zGetFeedItemsData, zGetFollowersData, zGetFollowingData, zGetHighlightedChannelsData, zGetManagedAppsData, zGetMetaTagsData, zGetMiniAppAnalyticsRollupData, zGetMutedKeywordsData, zGetMutualFollowersData, zGetNotificationsData, zGetOrCreateReferralCodeData, zGetOwnedDomainsData, zGetProfileCastsData, zGetRewardsLeaderboardData, zGetRewardsMetadataData, zGetSponsoredInvitesData, zGetStarterPackData, zGetStarterPackMembersData, zGetStarterPackUsersData, zGetSuggestedStarterPacksData, zGetSuggestedUsersData, zGetTopFrameAppsData, zGetTopMiniAppsData, zGetTrendingTopicsData, zGetUnseenCountsData, zGetUserAppContextData, zGetUserByFidData, zGetUserByUsernameData, zGetUserByVerificationAddressData, zGetUserData, zGetUserFavoriteFramesData, zGetUserFollowedChannelsData, zGetUserFollowingChannelsData, zGetUserLikedCastsData, zGetUserOnboardingStateData, zGetUserPreferencesData, zGetUserPrimaryAddressData, zGetUserPrimaryAddressesData, zGetUserRewardsScoresData, zGetUserStarterPacksData, zGetUserThreadCastsData, zGetVerificationsData, zGetXpClaimableSummaryData, zGetXpRewardsData, zHighlightedChannelsResponse, zImageEmbed, zInspectImageUrlData, zInspectMiniAppUrlData, zInviteUserToChannelData, zInvitesAvailableResponse, zLikeCastData, zLimitParam, zLocation, zMarkAllNotificationsReadData, zMiniApp, zMiniAppViewerContext, zModerateCastData, zMuteKeywordData, zMutedKeyword, zMutedKeywordProperties, zMutedKeywordsResponse, zNotificationsResponse, zOnboardingState, zOnboardingStateResponse, zPaginatedResponse, zPaginationCursor, zPinCastToChannelData, zPinDirectCastConversationData, zProfile, zProfilePicture, zRankedMiniApp, zRawChannel, zRawChannelResponse, zRecastCastData, zRecaster, zRegisterStatsigEventsData, zRemoveChannelInviteData, zRemoveDirectCastMessageReactionData, zRevokeApiKeyData, zRewardsLeaderboardResponse, zRewardsMetadataResponse, zRewardsScoresResponse, zSearchChannelsData, zSearchChannelsResponse, zSendDirectCastData, zSendDirectCastMessageData, zSetDirectCastConversationMessageTtlData, zSetLastCheckedTimestampData, zSponsoredInvitesResponse, zStarterPack, zStarterPackResponse, zStarterPackUpdateRequest, zStarterPackUsersResponse, zStarterPacksResponse, zSubmitAnalyticsEventsData, zSuccessResponse, zSuggestedUsersResponse, zTopMiniAppsResponse, zUnbanUserFromChannelData, zUnblockUserData, zUndoRecastData, zUnfollowChannelData, zUnlikeCastData, zUnmuteKeywordData, zUnpinCastFromChannelData, zUnpinDirectCastConversationData, zUnseenCountsResponse, zUpdateDirectCastConversationNotificationsData, zUpdateStarterPackData, zUrlEmbed, zUser, zUserAppContextResponse, zUserByFidResponse, zUserExtras, zUserPreferencesResponse, zUserResponse, zUserResponseUserResponse, zUserThreadCastsResponse, zUserWithExtras, zUsersResponse, zUsersWithCountResponse, zValidationError, zVerifiedAddress, zVideoEmbed, zViewerContext, zWinner };
//# sourceMappingURL=index.d.mts.map