onlyfans 0.1.0

data/rbi/onlyfans/models/account_list_response.rbi

@@ -0,0 +1,1496 @@
+# typed: strong
+
+module Onlyfans
+  module Models
+    class AccountListResponseItem < Onlyfans::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Onlyfans::Models::AccountListResponseItem,
+            Onlyfans::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :authentication_progress
+
+      sig { params(authentication_progress: String).void }
+      attr_writer :authentication_progress
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :display_name
+
+      sig { params(display_name: String).void }
+      attr_writer :display_name
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_authenticated
+
+      sig { params(is_authenticated: T::Boolean).void }
+      attr_writer :is_authenticated
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :onlyfans_email
+
+      sig { params(onlyfans_email: String).void }
+      attr_writer :onlyfans_email
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :onlyfans_id
+
+      sig { params(onlyfans_id: Integer).void }
+      attr_writer :onlyfans_id
+
+      sig do
+        returns(
+          T.nilable(Onlyfans::Models::AccountListResponseItem::OnlyfansUserData)
+        )
+      end
+      attr_reader :onlyfans_user_data
+
+      sig do
+        params(
+          onlyfans_user_data:
+            Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::OrHash
+        ).void
+      end
+      attr_writer :onlyfans_user_data
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :onlyfans_username
+
+      sig { params(onlyfans_username: String).void }
+      attr_writer :onlyfans_username
+
+      sig do
+        params(
+          id: String,
+          authentication_progress: String,
+          display_name: String,
+          is_authenticated: T::Boolean,
+          onlyfans_email: String,
+          onlyfans_id: Integer,
+          onlyfans_user_data:
+            Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::OrHash,
+          onlyfans_username: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id: nil,
+        authentication_progress: nil,
+        display_name: nil,
+        is_authenticated: nil,
+        onlyfans_email: nil,
+        onlyfans_id: nil,
+        onlyfans_user_data: nil,
+        onlyfans_username: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            authentication_progress: String,
+            display_name: String,
+            is_authenticated: T::Boolean,
+            onlyfans_email: String,
+            onlyfans_id: Integer,
+            onlyfans_user_data:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData,
+            onlyfans_username: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class OnlyfansUserData < Onlyfans::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData,
+              Onlyfans::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :id
+
+        sig { params(id: Integer).void }
+        attr_writer :id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :about
+
+        sig { params(about: String).void }
+        attr_writer :about
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :adv_block
+
+        sig { params(adv_block: T::Array[String]).void }
+        attr_writer :adv_block
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :age_verification_required
+
+        sig { params(age_verification_required: T::Boolean).void }
+        attr_writer :age_verification_required
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :archived_posts_count
+
+        sig { params(archived_posts_count: Integer).void }
+        attr_writer :archived_posts_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :audios_count
+
+        sig { params(audios_count: Integer).void }
+        attr_writer :audios_count
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :avatar
+
+        sig { params(avatar: String).void }
+        attr_writer :avatar
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :avatar_header_converter_upload
+
+        sig { params(avatar_header_converter_upload: T::Boolean).void }
+        attr_writer :avatar_header_converter_upload
+
+        sig do
+          returns(
+            T.nilable(
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::AvatarThumbs
+            )
+          )
+        end
+        attr_reader :avatar_thumbs
+
+        sig do
+          params(
+            avatar_thumbs:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::AvatarThumbs::OrHash
+          ).void
+        end
+        attr_writer :avatar_thumbs
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_add_card
+
+        sig { params(can_add_card: T::Boolean).void }
+        attr_writer :can_add_card
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_alternative_wallet_top_up
+
+        sig { params(can_alternative_wallet_top_up: T::Boolean).void }
+        attr_writer :can_alternative_wallet_top_up
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_chat
+
+        sig { params(can_chat: T::Boolean).void }
+        attr_writer :can_chat
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_comment_story
+
+        sig { params(can_comment_story: T::Boolean).void }
+        attr_writer :can_comment_story
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_connect_of_account
+
+        sig { params(can_connect_of_account: T::Boolean).void }
+        attr_writer :can_connect_of_account
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_create_lists
+
+        sig { params(can_create_lists: T::Boolean).void }
+        attr_writer :can_create_lists
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_look_story
+
+        sig { params(can_look_story: T::Boolean).void }
+        attr_writer :can_look_story
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_pay_internal
+
+        sig { params(can_pay_internal: T::Boolean).void }
+        attr_writer :can_pay_internal
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_pin_post
+
+        sig { params(can_pin_post: T::Boolean).void }
+        attr_writer :can_pin_post
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_receive_chat_message
+
+        sig { params(can_receive_chat_message: T::Boolean).void }
+        attr_writer :can_receive_chat_message
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :can_send_chat_to_all
+
+        sig { params(can_send_chat_to_all: T::Boolean).void }
+        attr_writer :can_send_chat_to_all
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :chat_messages_count
+
+        sig { params(chat_messages_count: Integer).void }
+        attr_writer :chat_messages_count
+
+        sig { returns(T.nilable(T::Array[T.anything])) }
+        attr_reader :connected_of_accounts
+
+        sig { params(connected_of_accounts: T::Array[T.anything]).void }
+        attr_writer :connected_of_accounts
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :count_pinned_chat
+
+        sig { params(count_pinned_chat: Integer).void }
+        attr_writer :count_pinned_chat
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :count_priority_chat
+
+        sig { params(count_priority_chat: Integer).void }
+        attr_writer :count_priority_chat
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :credit_balance
+
+        sig { params(credit_balance: Integer).void }
+        attr_writer :credit_balance
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :credits_max
+
+        sig { params(credits_max: Integer).void }
+        attr_writer :credits_max
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :credits_min
+
+        sig { params(credits_min: Integer).void }
+        attr_writer :credits_min
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :csrf
+
+        sig { params(csrf: String).void }
+        attr_writer :csrf
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :email
+
+        sig { params(email: String).void }
+        attr_writer :email
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :enabled_image_editor_for_chat
+
+        sig { params(enabled_image_editor_for_chat: T::Boolean).void }
+        attr_writer :enabled_image_editor_for_chat
+
+        sig { returns(T.nilable(T::Array[T.anything])) }
+        attr_reader :face_id_regular
+
+        sig { params(face_id_regular: T::Array[T.anything]).void }
+        attr_writer :face_id_regular
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :favorited_count
+
+        sig { params(favorited_count: Integer).void }
+        attr_writer :favorited_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :favorites_count
+
+        sig { params(favorites_count: Integer).void }
+        attr_writer :favorites_count
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_internal_payments
+
+        sig { params(has_internal_payments: T::Boolean).void }
+        attr_writer :has_internal_payments
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_labels
+
+        sig { params(has_labels: T::Boolean).void }
+        attr_writer :has_labels
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_new_alerts
+
+        sig { params(has_new_alerts: T::Boolean).void }
+        attr_writer :has_new_alerts
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_new_changed_price_subscriptions
+
+        sig { params(has_new_changed_price_subscriptions: T::Boolean).void }
+        attr_writer :has_new_changed_price_subscriptions
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_new_hints
+
+        sig { params(has_new_hints: T::Boolean).void }
+        attr_writer :has_new_hints
+
+        sig do
+          returns(
+            T.nilable(
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HasNewTicketReplies
+            )
+          )
+        end
+        attr_reader :has_new_ticket_replies
+
+        sig do
+          params(
+            has_new_ticket_replies:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HasNewTicketReplies::OrHash
+          ).void
+        end
+        attr_writer :has_new_ticket_replies
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_not_viewed_story
+
+        sig { params(has_not_viewed_story: T::Boolean).void }
+        attr_writer :has_not_viewed_story
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_pinned_posts
+
+        sig { params(has_pinned_posts: T::Boolean).void }
+        attr_writer :has_pinned_posts
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_purchased_posts
+
+        sig { params(has_purchased_posts: T::Boolean).void }
+        attr_writer :has_purchased_posts
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_scenario
+
+        sig { params(has_scenario: T::Boolean).void }
+        attr_writer :has_scenario
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_system_notifications
+
+        sig { params(has_system_notifications: T::Boolean).void }
+        attr_writer :has_system_notifications
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_tags
+
+        sig { params(has_tags: T::Boolean).void }
+        attr_writer :has_tags
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_watermark_photo
+
+        sig { params(has_watermark_photo: T::Boolean).void }
+        attr_writer :has_watermark_photo
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_watermark_video
+
+        sig { params(has_watermark_video: T::Boolean).void }
+        attr_writer :has_watermark_video
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :header
+
+        sig { params(header: String).void }
+        attr_writer :header
+
+        sig do
+          returns(
+            T.nilable(
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderSize
+            )
+          )
+        end
+        attr_reader :header_size
+
+        sig do
+          params(
+            header_size:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderSize::OrHash
+          ).void
+        end
+        attr_writer :header_size
+
+        sig do
+          returns(
+            T.nilable(
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderThumbs
+            )
+          )
+        end
+        attr_reader :header_thumbs
+
+        sig do
+          params(
+            header_thumbs:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderThumbs::OrHash
+          ).void
+        end
+        attr_writer :header_thumbs
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :ip
+
+        sig { params(ip: String).void }
+        attr_writer :ip
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_age_verified
+
+        sig { params(is_age_verified: T::Boolean).void }
+        attr_writer :is_age_verified
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_allow_tweets
+
+        sig { params(is_allow_tweets: T::Boolean).void }
+        attr_writer :is_allow_tweets
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_auth
+
+        sig { params(is_auth: T::Boolean).void }
+        attr_writer :is_auth
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_credits_enabled
+
+        sig { params(is_credits_enabled: T::Boolean).void }
+        attr_writer :is_credits_enabled
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_delete_initiated
+
+        sig { params(is_delete_initiated: T::Boolean).void }
+        attr_writer :is_delete_initiated
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_email_checked
+
+        sig { params(is_email_checked: T::Boolean).void }
+        attr_writer :is_email_checked
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_email_required
+
+        sig { params(is_email_required: T::Boolean).void }
+        attr_writer :is_email_required
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_legal_approved_allowed
+
+        sig { params(is_legal_approved_allowed: T::Boolean).void }
+        attr_writer :is_legal_approved_allowed
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_make_payment
+
+        sig { params(is_make_payment: T::Boolean).void }
+        attr_writer :is_make_payment
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_markdown_disabled_for_about
+
+        sig { params(is_markdown_disabled_for_about: T::Boolean).void }
+        attr_writer :is_markdown_disabled_for_about
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_otp_enabled
+
+        sig { params(is_otp_enabled: T::Boolean).void }
+        attr_writer :is_otp_enabled
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_payment_card_connected
+
+        sig { params(is_payment_card_connected: T::Boolean).void }
+        attr_writer :is_payment_card_connected
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_paywall_passed
+
+        sig { params(is_paywall_passed: T::Boolean).void }
+        attr_writer :is_paywall_passed
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_performer
+
+        sig { params(is_performer: T::Boolean).void }
+        attr_writer :is_performer
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_real_card_connected
+
+        sig { params(is_real_card_connected: T::Boolean).void }
+        attr_writer :is_real_card_connected
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_real_performer
+
+        sig { params(is_real_performer: T::Boolean).void }
+        attr_writer :is_real_performer
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_referrer_allowed
+
+        sig { params(is_referrer_allowed: T::Boolean).void }
+        attr_writer :is_referrer_allowed
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_spotify_connected
+
+        sig { params(is_spotify_connected: T::Boolean).void }
+        attr_writer :is_spotify_connected
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_twitter_connected
+
+        sig { params(is_twitter_connected: T::Boolean).void }
+        attr_writer :is_twitter_connected
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_verified
+
+        sig { params(is_verified: T::Boolean).void }
+        attr_writer :is_verified
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_visible_online
+
+        sig { params(is_visible_online: T::Boolean).void }
+        attr_writer :is_visible_online
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_wallet_autorecharge
+
+        sig { params(is_wallet_autorecharge: T::Boolean).void }
+        attr_writer :is_wallet_autorecharge
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_want_comments
+
+        sig { params(is_want_comments: T::Boolean).void }
+        attr_writer :is_want_comments
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :iv_country
+
+        sig { params(iv_country: String).void }
+        attr_writer :iv_country
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :iv_fail_reason
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :iv_flow
+
+        sig { params(iv_flow: String).void }
+        attr_writer :iv_flow
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :iv_status
+
+        sig { params(iv_status: String).void }
+        attr_writer :iv_status
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :join_date
+
+        sig { params(join_date: String).void }
+        attr_writer :join_date
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :last_seen
+
+        sig { params(last_seen: String).void }
+        attr_writer :last_seen
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :location
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_pinned_posts_count
+
+        sig { params(max_pinned_posts_count: Integer).void }
+        attr_writer :max_pinned_posts_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :medias_count
+
+        sig { params(medias_count: Integer).void }
+        attr_writer :medias_count
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :need_iv_approve
+
+        sig { params(need_iv_approve: T::Boolean).void }
+        attr_writer :need_iv_approve
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :new_tags_count
+
+        sig { params(new_tags_count: Integer).void }
+        attr_writer :new_tags_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :notifications_count
+
+        sig { params(notifications_count: Integer).void }
+        attr_writer :notifications_count
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :paid_feed
+
+        sig { params(paid_feed: T::Boolean).void }
+        attr_writer :paid_feed
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :payout_legal_approve_state
+
+        sig { params(payout_legal_approve_state: String).void }
+        attr_writer :payout_legal_approve_state
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :photos_count
+
+        sig { params(photos_count: Integer).void }
+        attr_writer :photos_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :pinned_posts_count
+
+        sig { params(pinned_posts_count: Integer).void }
+        attr_writer :pinned_posts_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :posts_count
+
+        sig { params(posts_count: Integer).void }
+        attr_writer :posts_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :private_archived_posts_count
+
+        sig { params(private_archived_posts_count: Integer).void }
+        attr_writer :private_archived_posts_count
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :show_posts_in_feed
+
+        sig { params(show_posts_in_feed: T::Boolean).void }
+        attr_writer :show_posts_in_feed
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :subscribers_count
+
+        sig { params(subscribers_count: Integer).void }
+        attr_writer :subscribers_count
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :subscribes_count
+
+        sig { params(subscribes_count: Integer).void }
+        attr_writer :subscribes_count
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :twitter_username
+
+        sig { params(twitter_username: String).void }
+        attr_writer :twitter_username
+
+        sig do
+          returns(
+            T.nilable(
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload
+            )
+          )
+        end
+        attr_reader :upload
+
+        sig do
+          params(
+            upload:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::OrHash
+          ).void
+        end
+        attr_writer :upload
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :username
+
+        sig { params(username: String).void }
+        attr_writer :username
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :videos_count
+
+        sig { params(videos_count: Integer).void }
+        attr_writer :videos_count
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :view
+
+        sig { params(view: String).void }
+        attr_writer :view
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :wallet_autorecharge_amount
+
+        sig { params(wallet_autorecharge_amount: Integer).void }
+        attr_writer :wallet_autorecharge_amount
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :wallet_autorecharge_min
+
+        sig { params(wallet_autorecharge_min: Integer).void }
+        attr_writer :wallet_autorecharge_min
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :wallet_first_rebills
+
+        sig { params(wallet_first_rebills: T::Boolean).void }
+        attr_writer :wallet_first_rebills
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :watermark_position
+
+        sig { params(watermark_position: String).void }
+        attr_writer :watermark_position
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :watermark_text
+
+        sig { params(watermark_text: String).void }
+        attr_writer :watermark_text
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :website
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :wishlist
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :ws_auth_token
+
+        sig { params(ws_auth_token: String).void }
+        attr_writer :ws_auth_token
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :ws_url
+
+        sig { params(ws_url: String).void }
+        attr_writer :ws_url
+
+        sig do
+          params(
+            id: Integer,
+            about: String,
+            adv_block: T::Array[String],
+            age_verification_required: T::Boolean,
+            archived_posts_count: Integer,
+            audios_count: Integer,
+            avatar: String,
+            avatar_header_converter_upload: T::Boolean,
+            avatar_thumbs:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::AvatarThumbs::OrHash,
+            can_add_card: T::Boolean,
+            can_alternative_wallet_top_up: T::Boolean,
+            can_chat: T::Boolean,
+            can_comment_story: T::Boolean,
+            can_connect_of_account: T::Boolean,
+            can_create_lists: T::Boolean,
+            can_look_story: T::Boolean,
+            can_pay_internal: T::Boolean,
+            can_pin_post: T::Boolean,
+            can_receive_chat_message: T::Boolean,
+            can_send_chat_to_all: T::Boolean,
+            chat_messages_count: Integer,
+            connected_of_accounts: T::Array[T.anything],
+            count_pinned_chat: Integer,
+            count_priority_chat: Integer,
+            credit_balance: Integer,
+            credits_max: Integer,
+            credits_min: Integer,
+            csrf: String,
+            email: String,
+            enabled_image_editor_for_chat: T::Boolean,
+            face_id_regular: T::Array[T.anything],
+            favorited_count: Integer,
+            favorites_count: Integer,
+            has_internal_payments: T::Boolean,
+            has_labels: T::Boolean,
+            has_new_alerts: T::Boolean,
+            has_new_changed_price_subscriptions: T::Boolean,
+            has_new_hints: T::Boolean,
+            has_new_ticket_replies:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HasNewTicketReplies::OrHash,
+            has_not_viewed_story: T::Boolean,
+            has_pinned_posts: T::Boolean,
+            has_purchased_posts: T::Boolean,
+            has_scenario: T::Boolean,
+            has_system_notifications: T::Boolean,
+            has_tags: T::Boolean,
+            has_watermark_photo: T::Boolean,
+            has_watermark_video: T::Boolean,
+            header: String,
+            header_size:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderSize::OrHash,
+            header_thumbs:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderThumbs::OrHash,
+            ip: String,
+            is_age_verified: T::Boolean,
+            is_allow_tweets: T::Boolean,
+            is_auth: T::Boolean,
+            is_credits_enabled: T::Boolean,
+            is_delete_initiated: T::Boolean,
+            is_email_checked: T::Boolean,
+            is_email_required: T::Boolean,
+            is_legal_approved_allowed: T::Boolean,
+            is_make_payment: T::Boolean,
+            is_markdown_disabled_for_about: T::Boolean,
+            is_otp_enabled: T::Boolean,
+            is_payment_card_connected: T::Boolean,
+            is_paywall_passed: T::Boolean,
+            is_performer: T::Boolean,
+            is_real_card_connected: T::Boolean,
+            is_real_performer: T::Boolean,
+            is_referrer_allowed: T::Boolean,
+            is_spotify_connected: T::Boolean,
+            is_twitter_connected: T::Boolean,
+            is_verified: T::Boolean,
+            is_visible_online: T::Boolean,
+            is_wallet_autorecharge: T::Boolean,
+            is_want_comments: T::Boolean,
+            iv_country: String,
+            iv_fail_reason: T.nilable(String),
+            iv_flow: String,
+            iv_status: String,
+            join_date: String,
+            last_seen: String,
+            location: T.nilable(String),
+            max_pinned_posts_count: Integer,
+            medias_count: Integer,
+            name: String,
+            need_iv_approve: T::Boolean,
+            new_tags_count: Integer,
+            notifications_count: Integer,
+            paid_feed: T::Boolean,
+            payout_legal_approve_state: String,
+            photos_count: Integer,
+            pinned_posts_count: Integer,
+            posts_count: Integer,
+            private_archived_posts_count: Integer,
+            show_posts_in_feed: T::Boolean,
+            subscribers_count: Integer,
+            subscribes_count: Integer,
+            twitter_username: String,
+            upload:
+              Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::OrHash,
+            username: String,
+            videos_count: Integer,
+            view: String,
+            wallet_autorecharge_amount: Integer,
+            wallet_autorecharge_min: Integer,
+            wallet_first_rebills: T::Boolean,
+            watermark_position: String,
+            watermark_text: String,
+            website: T.nilable(String),
+            wishlist: T.nilable(String),
+            ws_auth_token: String,
+            ws_url: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id: nil,
+          about: nil,
+          adv_block: nil,
+          age_verification_required: nil,
+          archived_posts_count: nil,
+          audios_count: nil,
+          avatar: nil,
+          avatar_header_converter_upload: nil,
+          avatar_thumbs: nil,
+          can_add_card: nil,
+          can_alternative_wallet_top_up: nil,
+          can_chat: nil,
+          can_comment_story: nil,
+          can_connect_of_account: nil,
+          can_create_lists: nil,
+          can_look_story: nil,
+          can_pay_internal: nil,
+          can_pin_post: nil,
+          can_receive_chat_message: nil,
+          can_send_chat_to_all: nil,
+          chat_messages_count: nil,
+          connected_of_accounts: nil,
+          count_pinned_chat: nil,
+          count_priority_chat: nil,
+          credit_balance: nil,
+          credits_max: nil,
+          credits_min: nil,
+          csrf: nil,
+          email: nil,
+          enabled_image_editor_for_chat: nil,
+          face_id_regular: nil,
+          favorited_count: nil,
+          favorites_count: nil,
+          has_internal_payments: nil,
+          has_labels: nil,
+          has_new_alerts: nil,
+          has_new_changed_price_subscriptions: nil,
+          has_new_hints: nil,
+          has_new_ticket_replies: nil,
+          has_not_viewed_story: nil,
+          has_pinned_posts: nil,
+          has_purchased_posts: nil,
+          has_scenario: nil,
+          has_system_notifications: nil,
+          has_tags: nil,
+          has_watermark_photo: nil,
+          has_watermark_video: nil,
+          header: nil,
+          header_size: nil,
+          header_thumbs: nil,
+          ip: nil,
+          is_age_verified: nil,
+          is_allow_tweets: nil,
+          is_auth: nil,
+          is_credits_enabled: nil,
+          is_delete_initiated: nil,
+          is_email_checked: nil,
+          is_email_required: nil,
+          is_legal_approved_allowed: nil,
+          is_make_payment: nil,
+          is_markdown_disabled_for_about: nil,
+          is_otp_enabled: nil,
+          is_payment_card_connected: nil,
+          is_paywall_passed: nil,
+          is_performer: nil,
+          is_real_card_connected: nil,
+          is_real_performer: nil,
+          is_referrer_allowed: nil,
+          is_spotify_connected: nil,
+          is_twitter_connected: nil,
+          is_verified: nil,
+          is_visible_online: nil,
+          is_wallet_autorecharge: nil,
+          is_want_comments: nil,
+          iv_country: nil,
+          iv_fail_reason: nil,
+          iv_flow: nil,
+          iv_status: nil,
+          join_date: nil,
+          last_seen: nil,
+          location: nil,
+          max_pinned_posts_count: nil,
+          medias_count: nil,
+          name: nil,
+          need_iv_approve: nil,
+          new_tags_count: nil,
+          notifications_count: nil,
+          paid_feed: nil,
+          payout_legal_approve_state: nil,
+          photos_count: nil,
+          pinned_posts_count: nil,
+          posts_count: nil,
+          private_archived_posts_count: nil,
+          show_posts_in_feed: nil,
+          subscribers_count: nil,
+          subscribes_count: nil,
+          twitter_username: nil,
+          upload: nil,
+          username: nil,
+          videos_count: nil,
+          view: nil,
+          wallet_autorecharge_amount: nil,
+          wallet_autorecharge_min: nil,
+          wallet_first_rebills: nil,
+          watermark_position: nil,
+          watermark_text: nil,
+          website: nil,
+          wishlist: nil,
+          ws_auth_token: nil,
+          ws_url: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: Integer,
+              about: String,
+              adv_block: T::Array[String],
+              age_verification_required: T::Boolean,
+              archived_posts_count: Integer,
+              audios_count: Integer,
+              avatar: String,
+              avatar_header_converter_upload: T::Boolean,
+              avatar_thumbs:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::AvatarThumbs,
+              can_add_card: T::Boolean,
+              can_alternative_wallet_top_up: T::Boolean,
+              can_chat: T::Boolean,
+              can_comment_story: T::Boolean,
+              can_connect_of_account: T::Boolean,
+              can_create_lists: T::Boolean,
+              can_look_story: T::Boolean,
+              can_pay_internal: T::Boolean,
+              can_pin_post: T::Boolean,
+              can_receive_chat_message: T::Boolean,
+              can_send_chat_to_all: T::Boolean,
+              chat_messages_count: Integer,
+              connected_of_accounts: T::Array[T.anything],
+              count_pinned_chat: Integer,
+              count_priority_chat: Integer,
+              credit_balance: Integer,
+              credits_max: Integer,
+              credits_min: Integer,
+              csrf: String,
+              email: String,
+              enabled_image_editor_for_chat: T::Boolean,
+              face_id_regular: T::Array[T.anything],
+              favorited_count: Integer,
+              favorites_count: Integer,
+              has_internal_payments: T::Boolean,
+              has_labels: T::Boolean,
+              has_new_alerts: T::Boolean,
+              has_new_changed_price_subscriptions: T::Boolean,
+              has_new_hints: T::Boolean,
+              has_new_ticket_replies:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HasNewTicketReplies,
+              has_not_viewed_story: T::Boolean,
+              has_pinned_posts: T::Boolean,
+              has_purchased_posts: T::Boolean,
+              has_scenario: T::Boolean,
+              has_system_notifications: T::Boolean,
+              has_tags: T::Boolean,
+              has_watermark_photo: T::Boolean,
+              has_watermark_video: T::Boolean,
+              header: String,
+              header_size:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderSize,
+              header_thumbs:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderThumbs,
+              ip: String,
+              is_age_verified: T::Boolean,
+              is_allow_tweets: T::Boolean,
+              is_auth: T::Boolean,
+              is_credits_enabled: T::Boolean,
+              is_delete_initiated: T::Boolean,
+              is_email_checked: T::Boolean,
+              is_email_required: T::Boolean,
+              is_legal_approved_allowed: T::Boolean,
+              is_make_payment: T::Boolean,
+              is_markdown_disabled_for_about: T::Boolean,
+              is_otp_enabled: T::Boolean,
+              is_payment_card_connected: T::Boolean,
+              is_paywall_passed: T::Boolean,
+              is_performer: T::Boolean,
+              is_real_card_connected: T::Boolean,
+              is_real_performer: T::Boolean,
+              is_referrer_allowed: T::Boolean,
+              is_spotify_connected: T::Boolean,
+              is_twitter_connected: T::Boolean,
+              is_verified: T::Boolean,
+              is_visible_online: T::Boolean,
+              is_wallet_autorecharge: T::Boolean,
+              is_want_comments: T::Boolean,
+              iv_country: String,
+              iv_fail_reason: T.nilable(String),
+              iv_flow: String,
+              iv_status: String,
+              join_date: String,
+              last_seen: String,
+              location: T.nilable(String),
+              max_pinned_posts_count: Integer,
+              medias_count: Integer,
+              name: String,
+              need_iv_approve: T::Boolean,
+              new_tags_count: Integer,
+              notifications_count: Integer,
+              paid_feed: T::Boolean,
+              payout_legal_approve_state: String,
+              photos_count: Integer,
+              pinned_posts_count: Integer,
+              posts_count: Integer,
+              private_archived_posts_count: Integer,
+              show_posts_in_feed: T::Boolean,
+              subscribers_count: Integer,
+              subscribes_count: Integer,
+              twitter_username: String,
+              upload:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload,
+              username: String,
+              videos_count: Integer,
+              view: String,
+              wallet_autorecharge_amount: Integer,
+              wallet_autorecharge_min: Integer,
+              wallet_first_rebills: T::Boolean,
+              watermark_position: String,
+              watermark_text: String,
+              website: T.nilable(String),
+              wishlist: T.nilable(String),
+              ws_auth_token: String,
+              ws_url: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class AvatarThumbs < Onlyfans::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::AvatarThumbs,
+                Onlyfans::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :c144
+
+          sig { params(c144: String).void }
+          attr_writer :c144
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :c50
+
+          sig { params(c50: String).void }
+          attr_writer :c50
+
+          sig { params(c144: String, c50: String).returns(T.attached_class) }
+          def self.new(c144: nil, c50: nil)
+          end
+
+          sig { override.returns({ c144: String, c50: String }) }
+          def to_hash
+          end
+        end
+
+        class HasNewTicketReplies < Onlyfans::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HasNewTicketReplies,
+                Onlyfans::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :closed
+
+          sig { params(closed: T::Boolean).void }
+          attr_writer :closed
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :open_
+
+          sig { params(open_: T::Boolean).void }
+          attr_writer :open_
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :solved
+
+          sig { params(solved: T::Boolean).void }
+          attr_writer :solved
+
+          sig do
+            params(
+              closed: T::Boolean,
+              open_: T::Boolean,
+              solved: T::Boolean
+            ).returns(T.attached_class)
+          end
+          def self.new(closed: nil, open_: nil, solved: nil)
+          end
+
+          sig do
+            override.returns(
+              { closed: T::Boolean, open_: T::Boolean, solved: T::Boolean }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class HeaderSize < Onlyfans::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderSize,
+                Onlyfans::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :height
+
+          sig { params(height: Integer).void }
+          attr_writer :height
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :width
+
+          sig { params(width: Integer).void }
+          attr_writer :width
+
+          sig do
+            params(height: Integer, width: Integer).returns(T.attached_class)
+          end
+          def self.new(height: nil, width: nil)
+          end
+
+          sig { override.returns({ height: Integer, width: Integer }) }
+          def to_hash
+          end
+        end
+
+        class HeaderThumbs < Onlyfans::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::HeaderThumbs,
+                Onlyfans::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :w480
+
+          sig { params(w480: String).void }
+          attr_writer :w480
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :w760
+
+          sig { params(w760: String).void }
+          attr_writer :w760
+
+          sig { params(w480: String, w760: String).returns(T.attached_class) }
+          def self.new(w480: nil, w760: nil)
+          end
+
+          sig { override.returns({ w480: String, w760: String }) }
+          def to_hash
+          end
+        end
+
+        class Upload < Onlyfans::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload,
+                Onlyfans::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T.nilable(
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs
+              )
+            )
+          end
+          attr_reader :geo_upload_args
+
+          sig do
+            params(
+              geo_upload_args:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::OrHash
+            ).void
+          end
+          attr_writer :geo_upload_args
+
+          sig do
+            params(
+              geo_upload_args:
+                Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(geo_upload_args: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                geo_upload_args:
+                  Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class GeoUploadArgs < Onlyfans::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs,
+                  Onlyfans::Internal::AnyHash
+                )
+              end
+
+            sig do
+              returns(
+                T.nilable(
+                  Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::Additional
+                )
+              )
+            end
+            attr_reader :additional
+
+            sig do
+              params(
+                additional:
+                  Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::Additional::OrHash
+              ).void
+            end
+            attr_writer :additional
+
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :is_delay
+
+            sig { params(is_delay: T::Boolean).void }
+            attr_writer :is_delay
+
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :need_thumbs
+
+            sig { params(need_thumbs: T::Boolean).void }
+            attr_writer :need_thumbs
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :preset
+
+            sig { params(preset: String).void }
+            attr_writer :preset
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :preset_png
+
+            sig { params(preset_png: String).void }
+            attr_writer :preset_png
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :protected_preset
+
+            sig { params(protected_preset: String).void }
+            attr_writer :protected_preset
+
+            sig do
+              params(
+                additional:
+                  Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::Additional::OrHash,
+                is_delay: T::Boolean,
+                need_thumbs: T::Boolean,
+                preset: String,
+                preset_png: String,
+                protected_preset: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              additional: nil,
+              is_delay: nil,
+              need_thumbs: nil,
+              preset: nil,
+              preset_png: nil,
+              protected_preset: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  additional:
+                    Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::Additional,
+                  is_delay: T::Boolean,
+                  need_thumbs: T::Boolean,
+                  preset: String,
+                  preset_png: String,
+                  protected_preset: String
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Additional < Onlyfans::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Onlyfans::Models::AccountListResponseItem::OnlyfansUserData::Upload::GeoUploadArgs::Additional,
+                    Onlyfans::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(T.nilable(String)) }
+              attr_reader :user
+
+              sig { params(user: String).void }
+              attr_writer :user
+
+              sig { params(user: String).returns(T.attached_class) }
+              def self.new(user: nil)
+              end
+
+              sig { override.returns({ user: String }) }
+              def to_hash
+              end
+            end
+          end
+        end
+      end
+    end
+
+    AccountListResponse =
+      T.let(
+        Onlyfans::Internal::Type::ArrayOf[
+          Onlyfans::Models::AccountListResponseItem
+        ],
+        Onlyfans::Internal::Type::Converter
+      )
+  end
+end