x-twitter-scraper 0.7.2 → 0.9.0

data/rbi/x_twitter_scraper/models/x/user_retrieve_followers_response.rbi

@@ -0,0 +1,440 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    module X
+      # Paginated user profiles. No-mode follower, following, and verified follower
+      # requests merge independent views automatically. Response fields, page size,
+      # aliases, filters, and per-returned-profile billing stay unchanged. Existing
+      # unprefixed cursors retain legacy behavior. Follow next_cursor while
+      # has_next_page is true.
+      module UserRetrieveFollowersResponse
+        extend XTwitterScraper::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::PaginatedUsers,
+              XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse
+            )
+          end
+
+        class UserListCoverageResponse < XTwitterScraper::Models::PaginatedUsers
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          # Coverage evidence across parallel relationship strategies.
+          sig do
+            returns(
+              XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic
+            )
+          end
+          attr_reader :diagnostic
+
+          sig do
+            params(
+              diagnostic:
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::OrHash
+            ).void
+          end
+          attr_writer :diagnostic
+
+          sig do
+            returns(
+              T.nilable(
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage::TaggedBoolean
+              )
+            )
+          end
+          attr_reader :has_next_page
+
+          sig do
+            params(
+              has_next_page:
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage::OrBoolean
+            ).void
+          end
+          attr_writer :has_next_page
+
+          sig do
+            returns(
+              T.nilable(
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :next_cursor
+
+          sig do
+            params(
+              next_cursor:
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor::OrSymbol
+            ).void
+          end
+          attr_writer :next_cursor
+
+          # Paginated user profiles. No-mode follower, following, and verified follower
+          # requests merge independent views automatically. Response fields, page size,
+          # aliases, filters, and per-returned-profile billing stay unchanged. Existing
+          # unprefixed cursors retain legacy behavior. Follow next_cursor while
+          # has_next_page is true.
+          sig do
+            params(
+              diagnostic:
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::OrHash,
+              has_next_page:
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage::OrBoolean,
+              next_cursor:
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Coverage evidence across parallel relationship strategies.
+            diagnostic:,
+            has_next_page: nil,
+            next_cursor: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                diagnostic:
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic,
+                has_next_page:
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage::TaggedBoolean,
+                next_cursor:
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Diagnostic < XTwitterScraper::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic,
+                  XTwitterScraper::Internal::AnyHash
+                )
+              end
+
+            # True when every strategy exhausted its source.
+            sig { returns(T::Boolean) }
+            attr_accessor :complete
+
+            sig { returns(Integer) }
+            attr_accessor :cursor_failure_count
+
+            sig { returns(T::Boolean) }
+            attr_accessor :deadline_reached
+
+            sig { returns(Integer) }
+            attr_accessor :duplicate_count
+
+            sig { returns(Integer) }
+            attr_accessor :failed_strategy_count
+
+            sig { returns(Integer) }
+            attr_accessor :malformed_count
+
+            sig { returns(Integer) }
+            attr_accessor :pages_fetched
+
+            # Whether credits or the requested limit reduced output.
+            sig { returns(T::Boolean) }
+            attr_accessor :response_truncated
+
+            sig { returns(T::Boolean) }
+            attr_accessor :result_limit_reached
+
+            sig { returns(Integer) }
+            attr_accessor :returned_users
+
+            sig { returns(Integer) }
+            attr_accessor :stalled_strategy_count
+
+            sig do
+              returns(
+                T::Array[
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy
+                ]
+              )
+            end
+            attr_accessor :strategies
+
+            sig { returns(Integer) }
+            attr_accessor :strategy_count
+
+            sig { returns(Integer) }
+            attr_accessor :unique_users
+
+            # Coverage evidence across parallel relationship strategies.
+            sig do
+              params(
+                complete: T::Boolean,
+                cursor_failure_count: Integer,
+                deadline_reached: T::Boolean,
+                duplicate_count: Integer,
+                failed_strategy_count: Integer,
+                malformed_count: Integer,
+                pages_fetched: Integer,
+                response_truncated: T::Boolean,
+                result_limit_reached: T::Boolean,
+                returned_users: Integer,
+                stalled_strategy_count: Integer,
+                strategies:
+                  T::Array[
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::OrHash
+                  ],
+                strategy_count: Integer,
+                unique_users: Integer
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # True when every strategy exhausted its source.
+              complete:,
+              cursor_failure_count:,
+              deadline_reached:,
+              duplicate_count:,
+              failed_strategy_count:,
+              malformed_count:,
+              pages_fetched:,
+              # Whether credits or the requested limit reduced output.
+              response_truncated:,
+              result_limit_reached:,
+              returned_users:,
+              stalled_strategy_count:,
+              strategies:,
+              strategy_count:,
+              unique_users:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  complete: T::Boolean,
+                  cursor_failure_count: Integer,
+                  deadline_reached: T::Boolean,
+                  duplicate_count: Integer,
+                  failed_strategy_count: Integer,
+                  malformed_count: Integer,
+                  pages_fetched: Integer,
+                  response_truncated: T::Boolean,
+                  result_limit_reached: T::Boolean,
+                  returned_users: Integer,
+                  stalled_strategy_count: Integer,
+                  strategies:
+                    T::Array[
+                      XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy
+                    ],
+                  strategy_count: Integer,
+                  unique_users: Integer
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Strategy < XTwitterScraper::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy,
+                    XTwitterScraper::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(Integer) }
+              attr_accessor :duplicate_count
+
+              sig { returns(Integer) }
+              attr_accessor :pages_fetched
+
+              sig do
+                returns(
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                )
+              end
+              attr_accessor :stop_reason
+
+              sig { returns(Integer) }
+              attr_accessor :strategy
+
+              sig { returns(Integer) }
+              attr_accessor :unique_added
+
+              sig do
+                params(
+                  duplicate_count: Integer,
+                  pages_fetched: Integer,
+                  stop_reason:
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::OrSymbol,
+                  strategy: Integer,
+                  unique_added: Integer
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                duplicate_count:,
+                pages_fetched:,
+                stop_reason:,
+                strategy:,
+                unique_added:
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    duplicate_count: Integer,
+                    pages_fetched: Integer,
+                    stop_reason:
+                      XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol,
+                    strategy: Integer,
+                    unique_added: Integer
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              module StopReason
+                extend XTwitterScraper::Internal::Type::Enum
+
+                TaggedSymbol =
+                  T.type_alias do
+                    T.all(
+                      Symbol,
+                      XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason
+                    )
+                  end
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                CURSOR_FAILURE =
+                  T.let(
+                    :cursor_failure,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+                DEADLINE =
+                  T.let(
+                    :deadline,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+                EXHAUSTED =
+                  T.let(
+                    :exhausted,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+                FAILED =
+                  T.let(
+                    :failed,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+                PAGE_LIMIT =
+                  T.let(
+                    :page_limit,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+                RESULT_LIMIT =
+                  T.let(
+                    :result_limit,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+                STALLED =
+                  T.let(
+                    :stalled,
+                    XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                  )
+
+                sig do
+                  override.returns(
+                    T::Array[
+                      XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::Diagnostic::Strategy::StopReason::TaggedSymbol
+                    ]
+                  )
+                end
+                def self.values
+                end
+              end
+            end
+          end
+
+          module HasNextPage
+            extend XTwitterScraper::Internal::Type::Enum
+
+            TaggedBoolean =
+              T.type_alias do
+                T.all(
+                  T::Boolean,
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage
+                )
+              end
+            OrBoolean = T.type_alias { T::Boolean }
+
+            FALSE =
+              T.let(
+                false,
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage::TaggedBoolean
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::HasNextPage::TaggedBoolean
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          module NextCursor
+            extend XTwitterScraper::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            EMPTY =
+              T.let(
+                :"",
+                XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  XTwitterScraper::Models::X::UserRetrieveFollowersResponse::UserListCoverageResponse::NextCursor::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[
+              XTwitterScraper::Models::X::UserRetrieveFollowersResponse::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/x/user_retrieve_followers_you_know_params.rbi

@@ -22,6 +22,13 @@ module XTwitterScraper
         sig { returns(String) }
         attr_accessor :id
 
+        # Match any comma-separated or line-separated bio term, ignoring case.
+        sig { returns(T.nilable(String)) }
+        attr_reader :bio_contains
+
+        sig { params(bio_contains: String).void }
+        attr_writer :bio_contains
+
         # Pagination cursor for followers-you-know
         sig { returns(T.nilable(String)) }
         attr_reader :cursor
@@ -29,33 +36,164 @@ module XTwitterScraper
         sig { params(cursor: String).void }
         attr_writer :cursor
 
-        # Maximum user profiles requested from this page (20-200, default 200). The
-        # response can contain fewer profiles because the source returned fewer or
-        # remaining credits cover fewer results. Keep requesting next_cursor while
-        # has_next_page is true. The deprecated limit and count aliases remain accepted.
+        # Only return profiles with a location.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_location
+
+        sig { params(has_location: T::Boolean).void }
+        attr_writer :has_location
+
+        # Only return profiles with a website.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :has_website
+
+        sig { params(has_website: T::Boolean).void }
+        attr_writer :has_website
+
+        # Match a location substring, ignoring case.
+        sig { returns(T.nilable(String)) }
+        attr_reader :location_contains
+
+        sig { params(location_contains: String).void }
+        attr_writer :location_contains
+
+        # Maximum follower count. Missing counts pass this maximum.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_followers
+
+        sig { params(max_followers: Integer).void }
+        attr_writer :max_followers
+
+        # Maximum following count.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_following
+
+        sig { params(max_following: Integer).void }
+        attr_writer :max_following
+
+        # Maximum post count. maxPosts is also accepted.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_statuses
+
+        sig { params(max_statuses: Integer).void }
+        attr_writer :max_statuses
+
+        # Minimum account age in whole days.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :min_account_age_days
+
+        sig { params(min_account_age_days: Integer).void }
+        attr_writer :min_account_age_days
+
+        # Minimum follower count. Filtering happens before billing.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :min_followers
+
+        sig { params(min_followers: Integer).void }
+        attr_writer :min_followers
+
+        # Minimum following count.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :min_following
+
+        sig { params(min_following: Integer).void }
+        attr_writer :min_following
+
+        # Minimum post count. minPosts is also accepted.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :min_statuses
+
+        sig { params(min_statuses: Integer).void }
+        attr_writer :min_statuses
+
+        # Maximum user profiles requested from this page (20-200, default 200). Source,
+        # filters, or credits can return fewer profiles. Keep requesting next_cursor while
+        # has_next_page is true. Deprecated aliases remain accepted.
         sig { returns(T.nilable(Integer)) }
         attr_reader :page_size
 
         sig { params(page_size: Integer).void }
         attr_writer :page_size
 
+        # Match a username substring, ignoring case.
+        sig { returns(T.nilable(String)) }
+        attr_reader :username_contains
+
+        sig { params(username_contains: String).void }
+        attr_writer :username_contains
+
+        # Only return verified profiles.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :verified_only
+
+        sig { params(verified_only: T::Boolean).void }
+        attr_writer :verified_only
+
+        # Match the verification type exactly, ignoring case.
+        sig { returns(T.nilable(String)) }
+        attr_reader :verified_type
+
+        sig { params(verified_type: String).void }
+        attr_writer :verified_type
+
         sig do
           params(
             id: String,
+            bio_contains: String,
             cursor: String,
+            has_location: T::Boolean,
+            has_website: T::Boolean,
+            location_contains: String,
+            max_followers: Integer,
+            max_following: Integer,
+            max_statuses: Integer,
+            min_account_age_days: Integer,
+            min_followers: Integer,
+            min_following: Integer,
+            min_statuses: Integer,
             page_size: Integer,
+            username_contains: String,
+            verified_only: T::Boolean,
+            verified_type: String,
             request_options: XTwitterScraper::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
         def self.new(
           id:,
+          # Match any comma-separated or line-separated bio term, ignoring case.
+          bio_contains: nil,
           # Pagination cursor for followers-you-know
           cursor: nil,
-          # Maximum user profiles requested from this page (20-200, default 200). The
-          # response can contain fewer profiles because the source returned fewer or
-          # remaining credits cover fewer results. Keep requesting next_cursor while
-          # has_next_page is true. The deprecated limit and count aliases remain accepted.
+          # Only return profiles with a location.
+          has_location: nil,
+          # Only return profiles with a website.
+          has_website: nil,
+          # Match a location substring, ignoring case.
+          location_contains: nil,
+          # Maximum follower count. Missing counts pass this maximum.
+          max_followers: nil,
+          # Maximum following count.
+          max_following: nil,
+          # Maximum post count. maxPosts is also accepted.
+          max_statuses: nil,
+          # Minimum account age in whole days.
+          min_account_age_days: nil,
+          # Minimum follower count. Filtering happens before billing.
+          min_followers: nil,
+          # Minimum following count.
+          min_following: nil,
+          # Minimum post count. minPosts is also accepted.
+          min_statuses: nil,
+          # Maximum user profiles requested from this page (20-200, default 200). Source,
+          # filters, or credits can return fewer profiles. Keep requesting next_cursor while
+          # has_next_page is true. Deprecated aliases remain accepted.
           page_size: nil,
+          # Match a username substring, ignoring case.
+          username_contains: nil,
+          # Only return verified profiles.
+          verified_only: nil,
+          # Match the verification type exactly, ignoring case.
+          verified_type: nil,
           request_options: {}
         )
         end
@@ -64,8 +202,22 @@ module XTwitterScraper
           override.returns(
             {
               id: String,
+              bio_contains: String,
               cursor: String,
+              has_location: T::Boolean,
+              has_website: T::Boolean,
+              location_contains: String,
+              max_followers: Integer,
+              max_following: Integer,
+              max_statuses: Integer,
+              min_account_age_days: Integer,
+              min_followers: Integer,
+              min_following: Integer,
+              min_statuses: Integer,
               page_size: Integer,
+              username_contains: String,
+              verified_only: T::Boolean,
+              verified_type: String,
               request_options: XTwitterScraper::RequestOptions
             }
           )