x-twitter-scraper 0.3.0

data/rbi/x_twitter_scraper/models/event_list_response.rbi

@@ -0,0 +1,168 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class EventListResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::EventListResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(T::Array[XTwitterScraper::Models::EventListResponse::Event])
+      end
+      attr_accessor :events
+
+      sig { returns(T::Boolean) }
+      attr_accessor :has_more
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :next_cursor
+
+      sig { params(next_cursor: String).void }
+      attr_writer :next_cursor
+
+      sig do
+        params(
+          events:
+            T::Array[XTwitterScraper::Models::EventListResponse::Event::OrHash],
+          has_more: T::Boolean,
+          next_cursor: String
+        ).returns(T.attached_class)
+      end
+      def self.new(events:, has_more:, next_cursor: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            events: T::Array[XTwitterScraper::Models::EventListResponse::Event],
+            has_more: T::Boolean,
+            next_cursor: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Event < XTwitterScraper::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::Models::EventListResponse::Event,
+              XTwitterScraper::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :data
+
+        sig { returns(String) }
+        attr_accessor :monitor_id
+
+        sig { returns(Time) }
+        attr_accessor :occurred_at
+
+        sig do
+          returns(
+            XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        sig { returns(String) }
+        attr_accessor :username
+
+        sig do
+          params(
+            id: String,
+            data: T::Hash[Symbol, T.anything],
+            monitor_id: String,
+            occurred_at: Time,
+            type:
+              XTwitterScraper::Models::EventListResponse::Event::Type::OrSymbol,
+            username: String
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, data:, monitor_id:, occurred_at:, type:, username:)
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              data: T::Hash[Symbol, T.anything],
+              monitor_id: String,
+              occurred_at: Time,
+              type:
+                XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol,
+              username: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend XTwitterScraper::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                XTwitterScraper::Models::EventListResponse::Event::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TWEET_NEW =
+            T.let(
+              :"tweet.new",
+              XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+            )
+          TWEET_REPLY =
+            T.let(
+              :"tweet.reply",
+              XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+            )
+          TWEET_RETWEET =
+            T.let(
+              :"tweet.retweet",
+              XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+            )
+          TWEET_QUOTE =
+            T.let(
+              :"tweet.quote",
+              XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+            )
+          FOLLOWER_GAINED =
+            T.let(
+              :"follower.gained",
+              XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+            )
+          FOLLOWER_LOST =
+            T.let(
+              :"follower.lost",
+              XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                XTwitterScraper::Models::EventListResponse::Event::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/event_retrieve_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class EventRetrieveParams < XTwitterScraper::Internal::Type::BaseModel
+      extend XTwitterScraper::Internal::Type::RequestParameters::Converter
+      include XTwitterScraper::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::EventRetrieveParams,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig do
+        params(
+          id: String,
+          request_options: XTwitterScraper::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { id: String, request_options: XTwitterScraper::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/event_retrieve_response.rbi

@@ -0,0 +1,135 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class EventRetrieveResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::EventRetrieveResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Event payload — shape varies by event type (JSON)
+      sig { returns(T::Hash[Symbol, T.anything]) }
+      attr_accessor :data
+
+      sig { returns(String) }
+      attr_accessor :monitor_id
+
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      sig do
+        returns(
+          XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+        )
+      end
+      attr_accessor :type
+
+      sig { returns(String) }
+      attr_accessor :username
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :x_event_id
+
+      sig { params(x_event_id: String).void }
+      attr_writer :x_event_id
+
+      sig do
+        params(
+          id: String,
+          data: T::Hash[Symbol, T.anything],
+          monitor_id: String,
+          occurred_at: Time,
+          type: XTwitterScraper::Models::EventRetrieveResponse::Type::OrSymbol,
+          username: String,
+          x_event_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Event payload — shape varies by event type (JSON)
+        data:,
+        monitor_id:,
+        occurred_at:,
+        type:,
+        username:,
+        x_event_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            data: T::Hash[Symbol, T.anything],
+            monitor_id: String,
+            occurred_at: Time,
+            type:
+              XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol,
+            username: String,
+            x_event_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, XTwitterScraper::Models::EventRetrieveResponse::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TWEET_NEW =
+          T.let(
+            :"tweet.new",
+            XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+          )
+        TWEET_REPLY =
+          T.let(
+            :"tweet.reply",
+            XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+          )
+        TWEET_RETWEET =
+          T.let(
+            :"tweet.retweet",
+            XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+          )
+        TWEET_QUOTE =
+          T.let(
+            :"tweet.quote",
+            XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+          )
+        FOLLOWER_GAINED =
+          T.let(
+            :"follower.gained",
+            XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+          )
+        FOLLOWER_LOST =
+          T.let(
+            :"follower.lost",
+            XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              XTwitterScraper::Models::EventRetrieveResponse::Type::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/event_type.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    module EventType
+      extend XTwitterScraper::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, XTwitterScraper::EventType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      TWEET_NEW = T.let(:"tweet.new", XTwitterScraper::EventType::TaggedSymbol)
+      TWEET_REPLY =
+        T.let(:"tweet.reply", XTwitterScraper::EventType::TaggedSymbol)
+      TWEET_RETWEET =
+        T.let(:"tweet.retweet", XTwitterScraper::EventType::TaggedSymbol)
+      TWEET_QUOTE =
+        T.let(:"tweet.quote", XTwitterScraper::EventType::TaggedSymbol)
+      FOLLOWER_GAINED =
+        T.let(:"follower.gained", XTwitterScraper::EventType::TaggedSymbol)
+      FOLLOWER_LOST =
+        T.let(:"follower.lost", XTwitterScraper::EventType::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[XTwitterScraper::EventType::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/extraction_estimate_cost_params.rbi

@@ -0,0 +1,261 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class ExtractionEstimateCostParams < XTwitterScraper::Internal::Type::BaseModel
+      extend XTwitterScraper::Internal::Type::RequestParameters::Converter
+      include XTwitterScraper::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::ExtractionEstimateCostParams,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(
+          XTwitterScraper::ExtractionEstimateCostParams::ToolType::OrSymbol
+        )
+      end
+      attr_accessor :tool_type
+
+      # Raw advanced search query appended as-is (tweet_search_extractor)
+      sig { returns(T.nilable(String)) }
+      attr_reader :advanced_query
+
+      sig { params(advanced_query: String).void }
+      attr_writer :advanced_query
+
+      # Exact phrase to match (tweet_search_extractor)
+      sig { returns(T.nilable(String)) }
+      attr_reader :exact_phrase
+
+      sig { params(exact_phrase: String).void }
+      attr_writer :exact_phrase
+
+      # Words to exclude from results (tweet_search_extractor)
+      sig { returns(T.nilable(String)) }
+      attr_reader :exclude_words
+
+      sig { params(exclude_words: String).void }
+      attr_writer :exclude_words
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :search_query
+
+      sig { params(search_query: String).void }
+      attr_writer :search_query
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target_community_id
+
+      sig { params(target_community_id: String).void }
+      attr_writer :target_community_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target_list_id
+
+      sig { params(target_list_id: String).void }
+      attr_writer :target_list_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target_space_id
+
+      sig { params(target_space_id: String).void }
+      attr_writer :target_space_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target_tweet_id
+
+      sig { params(target_tweet_id: String).void }
+      attr_writer :target_tweet_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target_username
+
+      sig { params(target_username: String).void }
+      attr_writer :target_username
+
+      sig do
+        params(
+          tool_type:
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::OrSymbol,
+          advanced_query: String,
+          exact_phrase: String,
+          exclude_words: String,
+          search_query: String,
+          target_community_id: String,
+          target_list_id: String,
+          target_space_id: String,
+          target_tweet_id: String,
+          target_username: String,
+          request_options: XTwitterScraper::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        tool_type:,
+        # Raw advanced search query appended as-is (tweet_search_extractor)
+        advanced_query: nil,
+        # Exact phrase to match (tweet_search_extractor)
+        exact_phrase: nil,
+        # Words to exclude from results (tweet_search_extractor)
+        exclude_words: nil,
+        search_query: nil,
+        target_community_id: nil,
+        target_list_id: nil,
+        target_space_id: nil,
+        target_tweet_id: nil,
+        target_username: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            tool_type:
+              XTwitterScraper::ExtractionEstimateCostParams::ToolType::OrSymbol,
+            advanced_query: String,
+            exact_phrase: String,
+            exclude_words: String,
+            search_query: String,
+            target_community_id: String,
+            target_list_id: String,
+            target_space_id: String,
+            target_tweet_id: String,
+            target_username: String,
+            request_options: XTwitterScraper::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module ToolType
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              XTwitterScraper::ExtractionEstimateCostParams::ToolType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ARTICLE_EXTRACTOR =
+          T.let(
+            :article_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        COMMUNITY_EXTRACTOR =
+          T.let(
+            :community_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        COMMUNITY_MODERATOR_EXPLORER =
+          T.let(
+            :community_moderator_explorer,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        COMMUNITY_POST_EXTRACTOR =
+          T.let(
+            :community_post_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        COMMUNITY_SEARCH =
+          T.let(
+            :community_search,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        FOLLOWER_EXPLORER =
+          T.let(
+            :follower_explorer,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        FOLLOWING_EXPLORER =
+          T.let(
+            :following_explorer,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        LIST_FOLLOWER_EXPLORER =
+          T.let(
+            :list_follower_explorer,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        LIST_MEMBER_EXTRACTOR =
+          T.let(
+            :list_member_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        LIST_POST_EXTRACTOR =
+          T.let(
+            :list_post_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        MENTION_EXTRACTOR =
+          T.let(
+            :mention_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        PEOPLE_SEARCH =
+          T.let(
+            :people_search,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        POST_EXTRACTOR =
+          T.let(
+            :post_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        QUOTE_EXTRACTOR =
+          T.let(
+            :quote_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        REPLY_EXTRACTOR =
+          T.let(
+            :reply_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        REPOST_EXTRACTOR =
+          T.let(
+            :repost_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        SPACE_EXPLORER =
+          T.let(
+            :space_explorer,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        THREAD_EXTRACTOR =
+          T.let(
+            :thread_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        TWEET_SEARCH_EXTRACTOR =
+          T.let(
+            :tweet_search_extractor,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+        VERIFIED_FOLLOWER_EXPLORER =
+          T.let(
+            :verified_follower_explorer,
+            XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              XTwitterScraper::ExtractionEstimateCostParams::ToolType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/extraction_estimate_cost_response.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class ExtractionEstimateCostResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::ExtractionEstimateCostResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :allowed
+
+      sig { returns(Integer) }
+      attr_accessor :estimated_results
+
+      sig { returns(Float) }
+      attr_accessor :projected_percent
+
+      sig { returns(String) }
+      attr_accessor :source
+
+      sig { returns(Float) }
+      attr_accessor :usage_percent
+
+      sig do
+        params(
+          allowed: T::Boolean,
+          estimated_results: Integer,
+          projected_percent: Float,
+          source: String,
+          usage_percent: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        allowed:,
+        estimated_results:,
+        projected_percent:,
+        source:,
+        usage_percent:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            allowed: T::Boolean,
+            estimated_results: Integer,
+            projected_percent: Float,
+            source: String,
+            usage_percent: Float
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end