x-twitter-scraper 0.4.2 → 0.4.4

data/rbi/x_twitter_scraper/models/trend_list_params.rbi

@@ -14,14 +14,14 @@ module XTwitterScraper
           )
         end
 
-      # Number of trending topics to return (1-50, default 30)
+      # Number of trending topics returned (1-50, default 30)
       sig { returns(T.nilable(Integer)) }
       attr_reader :count
 
       sig { params(count: Integer).void }
       attr_writer :count
 
-      # Region WOEID (1=Worldwide, 23424977=US, 23424975=UK, 23424969=Turkey)
+      # Region Yahoo WOEID code (1=Worldwide, 23424977=US, 23424975=UK, 23424969=Turkey)
       sig { returns(T.nilable(Integer)) }
       attr_reader :woeid
 
@@ -36,9 +36,9 @@ module XTwitterScraper
         ).returns(T.attached_class)
       end
       def self.new(
-        # Number of trending topics to return (1-50, default 30)
+        # Number of trending topics returned (1-50, default 30)
         count: nil,
-        # Region WOEID (1=Worldwide, 23424977=US, 23424975=UK, 23424969=Turkey)
+        # Region Yahoo WOEID code (1=Worldwide, 23424977=US, 23424975=UK, 23424969=Turkey)
         woeid: nil,
         request_options: {}
       )

data/rbi/x_twitter_scraper/models/tweet_media.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class TweetMedia < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(XTwitterScraper::TweetMedia, XTwitterScraper::Internal::AnyHash)
+        end
+
+      # Media preview URL
+      sig { returns(String) }
+      attr_accessor :media_url
+
+      sig { returns(XTwitterScraper::TweetMedia::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # X media link from the tweet
+      sig { returns(String) }
+      attr_accessor :url
+
+      # Available video encodings, ordered as returned
+      sig do
+        returns(T.nilable(T::Array[XTwitterScraper::TweetMedia::VideoVariant]))
+      end
+      attr_reader :video_variants
+
+      sig do
+        params(
+          video_variants:
+            T::Array[XTwitterScraper::TweetMedia::VideoVariant::OrHash]
+        ).void
+      end
+      attr_writer :video_variants
+
+      # Normalized media attached to a tweet.
+      sig do
+        params(
+          media_url: String,
+          type: XTwitterScraper::TweetMedia::Type::OrSymbol,
+          url: String,
+          video_variants:
+            T::Array[XTwitterScraper::TweetMedia::VideoVariant::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Media preview URL
+        media_url:,
+        type:,
+        # X media link from the tweet
+        url:,
+        # Available video encodings, ordered as returned
+        video_variants: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            media_url: String,
+            type: XTwitterScraper::TweetMedia::Type::TaggedSymbol,
+            url: String,
+            video_variants: T::Array[XTwitterScraper::TweetMedia::VideoVariant]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, XTwitterScraper::TweetMedia::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PHOTO = T.let(:photo, XTwitterScraper::TweetMedia::Type::TaggedSymbol)
+        VIDEO = T.let(:video, XTwitterScraper::TweetMedia::Type::TaggedSymbol)
+        ANIMATED_GIF =
+          T.let(:animated_gif, XTwitterScraper::TweetMedia::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[XTwitterScraper::TweetMedia::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class VideoVariant < XTwitterScraper::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::TweetMedia::VideoVariant,
+              XTwitterScraper::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :content_type
+
+        sig { returns(String) }
+        attr_accessor :url
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :bitrate
+
+        sig { params(bitrate: Integer).void }
+        attr_writer :bitrate
+
+        sig do
+          params(content_type: String, url: String, bitrate: Integer).returns(
+            T.attached_class
+          )
+        end
+        def self.new(content_type:, url:, bitrate: nil)
+        end
+
+        sig do
+          override.returns(
+            { content_type: String, url: String, bitrate: Integer }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/user_profile.rbi

@@ -0,0 +1,346 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class UserProfile < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::UserProfile,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(String) }
+      attr_accessor :username
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :automated_by
+
+      sig { params(automated_by: String).void }
+      attr_writer :automated_by
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :can_dm
+
+      sig { params(can_dm: T::Boolean).void }
+      attr_writer :can_dm
+
+      # Community role when returned by community member reads
+      sig { returns(T.nilable(String)) }
+      attr_reader :community_role
+
+      sig { params(community_role: String).void }
+      attr_writer :community_role
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :cover_picture
+
+      sig { params(cover_picture: String).void }
+      attr_writer :cover_picture
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_at
+
+      sig { params(created_at: String).void }
+      attr_writer :created_at
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :favourites_count
+
+      sig { params(favourites_count: Integer).void }
+      attr_writer :favourites_count
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :followers
+
+      sig { params(followers: Integer).void }
+      attr_writer :followers
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :following
+
+      sig { params(following: Integer).void }
+      attr_writer :following
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :has_custom_timelines
+
+      sig { params(has_custom_timelines: T::Boolean).void }
+      attr_writer :has_custom_timelines
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_automated
+
+      sig { params(is_automated: T::Boolean).void }
+      attr_writer :is_automated
+
+      # Whether X shows a blue verification badge
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_blue_verified
+
+      sig { params(is_blue_verified: T::Boolean).void }
+      attr_writer :is_blue_verified
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_translator
+
+      sig { params(is_translator: T::Boolean).void }
+      attr_writer :is_translator
+
+      # Whether X marks the profile as verified
+      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(String)) }
+      attr_reader :location
+
+      sig { params(location: String).void }
+      attr_writer :location
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :media_count
+
+      sig { params(media_count: Integer).void }
+      attr_writer :media_count
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :pinned_tweet_ids
+
+      sig { params(pinned_tweet_ids: T::Array[String]).void }
+      attr_writer :pinned_tweet_ids
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :possibly_sensitive
+
+      sig { params(possibly_sensitive: T::Boolean).void }
+      attr_writer :possibly_sensitive
+
+      # Structured profile bio with entity annotations
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :profile_bio
+
+      sig { params(profile_bio: T::Hash[Symbol, T.anything]).void }
+      attr_writer :profile_bio
+
+      # Original X profile banner field when available
+      sig { returns(T.nilable(String)) }
+      attr_reader :profile_banner_url
+
+      sig { params(profile_banner_url: String).void }
+      attr_writer :profile_banner_url
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :profile_picture
+
+      sig { params(profile_picture: String).void }
+      attr_writer :profile_picture
+
+      # Whether the profile protects its posts
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :protected
+
+      sig { params(protected: T::Boolean).void }
+      attr_writer :protected
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :statuses_count
+
+      sig { params(statuses_count: Integer).void }
+      attr_writer :statuses_count
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :unavailable
+
+      sig { params(unavailable: T::Boolean).void }
+      attr_writer :unavailable
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :unavailable_reason
+
+      sig { params(unavailable_reason: String).void }
+      attr_writer :unavailable_reason
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+
+      sig { params(url: String).void }
+      attr_writer :url
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :verified
+
+      sig { params(verified: T::Boolean).void }
+      attr_writer :verified
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :verified_type
+
+      sig { params(verified_type: String).void }
+      attr_writer :verified_type
+
+      # Whether this profile follows the authenticated viewer
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :viewer_followed_by
+
+      sig { params(viewer_followed_by: T::Boolean).void }
+      attr_writer :viewer_followed_by
+
+      # Whether the authenticated viewer follows this profile
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :viewer_following
+
+      sig { params(viewer_following: T::Boolean).void }
+      attr_writer :viewer_following
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :withheld_in_countries
+
+      sig { params(withheld_in_countries: T::Array[String]).void }
+      attr_writer :withheld_in_countries
+
+      # X user profile with bio, follower counts, and verification status.
+      sig do
+        params(
+          id: String,
+          name: String,
+          username: String,
+          automated_by: String,
+          can_dm: T::Boolean,
+          community_role: String,
+          cover_picture: String,
+          created_at: String,
+          description: String,
+          favourites_count: Integer,
+          followers: Integer,
+          following: Integer,
+          has_custom_timelines: T::Boolean,
+          is_automated: T::Boolean,
+          is_blue_verified: T::Boolean,
+          is_translator: T::Boolean,
+          is_verified: T::Boolean,
+          location: String,
+          media_count: Integer,
+          pinned_tweet_ids: T::Array[String],
+          possibly_sensitive: T::Boolean,
+          profile_bio: T::Hash[Symbol, T.anything],
+          profile_banner_url: String,
+          profile_picture: String,
+          protected: T::Boolean,
+          statuses_count: Integer,
+          unavailable: T::Boolean,
+          unavailable_reason: String,
+          url: String,
+          verified: T::Boolean,
+          verified_type: String,
+          viewer_followed_by: T::Boolean,
+          viewer_following: T::Boolean,
+          withheld_in_countries: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        name:,
+        username:,
+        automated_by: nil,
+        can_dm: nil,
+        # Community role when returned by community member reads
+        community_role: nil,
+        cover_picture: nil,
+        created_at: nil,
+        description: nil,
+        favourites_count: nil,
+        followers: nil,
+        following: nil,
+        has_custom_timelines: nil,
+        is_automated: nil,
+        # Whether X shows a blue verification badge
+        is_blue_verified: nil,
+        is_translator: nil,
+        # Whether X marks the profile as verified
+        is_verified: nil,
+        location: nil,
+        media_count: nil,
+        pinned_tweet_ids: nil,
+        possibly_sensitive: nil,
+        # Structured profile bio with entity annotations
+        profile_bio: nil,
+        # Original X profile banner field when available
+        profile_banner_url: nil,
+        profile_picture: nil,
+        # Whether the profile protects its posts
+        protected: nil,
+        statuses_count: nil,
+        unavailable: nil,
+        unavailable_reason: nil,
+        url: nil,
+        verified: nil,
+        verified_type: nil,
+        # Whether this profile follows the authenticated viewer
+        viewer_followed_by: nil,
+        # Whether the authenticated viewer follows this profile
+        viewer_following: nil,
+        withheld_in_countries: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            name: String,
+            username: String,
+            automated_by: String,
+            can_dm: T::Boolean,
+            community_role: String,
+            cover_picture: String,
+            created_at: String,
+            description: String,
+            favourites_count: Integer,
+            followers: Integer,
+            following: Integer,
+            has_custom_timelines: T::Boolean,
+            is_automated: T::Boolean,
+            is_blue_verified: T::Boolean,
+            is_translator: T::Boolean,
+            is_verified: T::Boolean,
+            location: String,
+            media_count: Integer,
+            pinned_tweet_ids: T::Array[String],
+            possibly_sensitive: T::Boolean,
+            profile_bio: T::Hash[Symbol, T.anything],
+            profile_banner_url: String,
+            profile_picture: String,
+            protected: T::Boolean,
+            statuses_count: Integer,
+            unavailable: T::Boolean,
+            unavailable_reason: String,
+            url: String,
+            verified: T::Boolean,
+            verified_type: String,
+            viewer_followed_by: T::Boolean,
+            viewer_following: T::Boolean,
+            withheld_in_countries: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/webhook.rbi

@@ -11,13 +11,26 @@ module XTwitterScraper
       sig { returns(String) }
       attr_accessor :id
 
+      # Consecutive failed delivery attempts since the last success.
+      sig { returns(Integer) }
+      attr_accessor :consecutive_failures
+
       sig { returns(Time) }
       attr_accessor :created_at
 
+      # Endpoint delivery state. needs_attention means delivery stopped after repeated
+      # failures.
+      sig { returns(XTwitterScraper::Webhook::DeliveryStatus::TaggedSymbol) }
+      attr_accessor :delivery_status
+
       # Array of event types to subscribe to.
       sig { returns(T::Array[XTwitterScraper::EventType::TaggedSymbol]) }
       attr_accessor :event_types
 
+      # Consecutive delivery failures that pause the endpoint.
+      sig { returns(Integer) }
+      attr_accessor :failure_hard_cap
+
       sig { returns(T::Boolean) }
       attr_accessor :is_active
 
@@ -28,17 +41,27 @@ module XTwitterScraper
       sig do
         params(
           id: String,
+          consecutive_failures: Integer,
           created_at: Time,
+          delivery_status: XTwitterScraper::Webhook::DeliveryStatus::OrSymbol,
           event_types: T::Array[XTwitterScraper::EventType::OrSymbol],
+          failure_hard_cap: Integer,
           is_active: T::Boolean,
           url: String
         ).returns(T.attached_class)
       end
       def self.new(
         id:,
+        # Consecutive failed delivery attempts since the last success.
+        consecutive_failures:,
         created_at:,
+        # Endpoint delivery state. needs_attention means delivery stopped after repeated
+        # failures.
+        delivery_status:,
         # Array of event types to subscribe to.
         event_types:,
+        # Consecutive delivery failures that pause the endpoint.
+        failure_hard_cap:,
         is_active:,
         url:
       )
@@ -48,8 +71,12 @@ module XTwitterScraper
         override.returns(
           {
             id: String,
+            consecutive_failures: Integer,
             created_at: Time,
+            delivery_status:
+              XTwitterScraper::Webhook::DeliveryStatus::TaggedSymbol,
             event_types: T::Array[XTwitterScraper::EventType::TaggedSymbol],
+            failure_hard_cap: Integer,
             is_active: T::Boolean,
             url: String
           }
@@ -57,6 +84,36 @@ module XTwitterScraper
       end
       def to_hash
       end
+
+      # Endpoint delivery state. needs_attention means delivery stopped after repeated
+      # failures.
+      module DeliveryStatus
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, XTwitterScraper::Webhook::DeliveryStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE =
+          T.let(:active, XTwitterScraper::Webhook::DeliveryStatus::TaggedSymbol)
+        PAUSED =
+          T.let(:paused, XTwitterScraper::Webhook::DeliveryStatus::TaggedSymbol)
+        NEEDS_ATTENTION =
+          T.let(
+            :needs_attention,
+            XTwitterScraper::Webhook::DeliveryStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[XTwitterScraper::Webhook::DeliveryStatus::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/x_twitter_scraper/models/webhook_create_response.rbi

@@ -21,6 +21,7 @@ module XTwitterScraper
       sig { returns(T::Array[XTwitterScraper::EventType::TaggedSymbol]) }
       attr_accessor :event_types
 
+      # Plaintext HMAC signing secret returned only at creation.
       sig { returns(String) }
       attr_accessor :secret
 
@@ -41,6 +42,7 @@ module XTwitterScraper
         created_at:,
         # Array of event types to subscribe to.
         event_types:,
+        # Plaintext HMAC signing secret returned only at creation.
         secret:,
         url:
       )

data/rbi/x_twitter_scraper/models/{api_key_revoke_params.rbi → webhook_resume_params.rbi}

@@ -2,14 +2,14 @@
 
 module XTwitterScraper
   module Models
-    class APIKeyRevokeParams < XTwitterScraper::Internal::Type::BaseModel
+    class WebhookResumeParams < XTwitterScraper::Internal::Type::BaseModel
       extend XTwitterScraper::Internal::Type::RequestParameters::Converter
       include XTwitterScraper::Internal::Type::RequestParameters
 
       OrHash =
         T.type_alias do
           T.any(
-            XTwitterScraper::APIKeyRevokeParams,
+            XTwitterScraper::WebhookResumeParams,
             XTwitterScraper::Internal::AnyHash
           )
         end

data/rbi/x_twitter_scraper/models/webhook_resume_response.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class WebhookResumeResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::WebhookResumeResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Integer) }
+      attr_accessor :status_code
+
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      # Webhook endpoint registered to receive event deliveries.
+      sig { returns(XTwitterScraper::Webhook) }
+      attr_reader :webhook
+
+      sig { params(webhook: XTwitterScraper::Webhook::OrHash).void }
+      attr_writer :webhook
+
+      sig do
+        params(
+          status_code: Integer,
+          success: T::Boolean,
+          webhook: XTwitterScraper::Webhook::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        status_code:,
+        success:,
+        # Webhook endpoint registered to receive event deliveries.
+        webhook:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            status_code: Integer,
+            success: T::Boolean,
+            webhook: XTwitterScraper::Webhook
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end