x-twitter-scraper 0.3.0

data/rbi/x_twitter_scraper/models/compose_create_params.rbi

@@ -0,0 +1,281 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class ComposeCreateParams < XTwitterScraper::Internal::Type::BaseModel
+      extend XTwitterScraper::Internal::Type::RequestParameters::Converter
+      include XTwitterScraper::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::ComposeCreateParams,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      # Workflow step
+      sig { returns(XTwitterScraper::ComposeCreateParams::Step::OrSymbol) }
+      attr_accessor :step
+
+      # Extra context or URLs (refine)
+      sig { returns(T.nilable(String)) }
+      attr_reader :additional_context
+
+      sig { params(additional_context: String).void }
+      attr_writer :additional_context
+
+      # Desired call to action (refine)
+      sig { returns(T.nilable(String)) }
+      attr_reader :call_to_action
+
+      sig { params(call_to_action: String).void }
+      attr_writer :call_to_action
+
+      # Tweet draft text to evaluate (score)
+      sig { returns(T.nilable(String)) }
+      attr_reader :draft
+
+      sig { params(draft: String).void }
+      attr_writer :draft
+
+      # Optimization goal
+      sig do
+        returns(T.nilable(XTwitterScraper::ComposeCreateParams::Goal::OrSymbol))
+      end
+      attr_reader :goal
+
+      sig do
+        params(goal: XTwitterScraper::ComposeCreateParams::Goal::OrSymbol).void
+      end
+      attr_writer :goal
+
+      # Whether a link is attached (score)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :has_link
+
+      sig { params(has_link: T::Boolean).void }
+      attr_writer :has_link
+
+      # Whether media is attached (score)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :has_media
+
+      sig { params(has_media: T::Boolean).void }
+      attr_writer :has_media
+
+      # Media type (refine)
+      sig do
+        returns(
+          T.nilable(XTwitterScraper::ComposeCreateParams::MediaType::OrSymbol)
+        )
+      end
+      attr_reader :media_type
+
+      sig do
+        params(
+          media_type: XTwitterScraper::ComposeCreateParams::MediaType::OrSymbol
+        ).void
+      end
+      attr_writer :media_type
+
+      # Cached style username for voice matching (compose)
+      sig { returns(T.nilable(String)) }
+      attr_reader :style_username
+
+      sig { params(style_username: String).void }
+      attr_writer :style_username
+
+      # Desired tone (refine)
+      sig { returns(T.nilable(String)) }
+      attr_reader :tone
+
+      sig { params(tone: String).void }
+      attr_writer :tone
+
+      # Tweet topic (compose, refine)
+      sig { returns(T.nilable(String)) }
+      attr_reader :topic
+
+      sig { params(topic: String).void }
+      attr_writer :topic
+
+      sig do
+        params(
+          step: XTwitterScraper::ComposeCreateParams::Step::OrSymbol,
+          additional_context: String,
+          call_to_action: String,
+          draft: String,
+          goal: XTwitterScraper::ComposeCreateParams::Goal::OrSymbol,
+          has_link: T::Boolean,
+          has_media: T::Boolean,
+          media_type: XTwitterScraper::ComposeCreateParams::MediaType::OrSymbol,
+          style_username: String,
+          tone: String,
+          topic: String,
+          request_options: XTwitterScraper::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Workflow step
+        step:,
+        # Extra context or URLs (refine)
+        additional_context: nil,
+        # Desired call to action (refine)
+        call_to_action: nil,
+        # Tweet draft text to evaluate (score)
+        draft: nil,
+        # Optimization goal
+        goal: nil,
+        # Whether a link is attached (score)
+        has_link: nil,
+        # Whether media is attached (score)
+        has_media: nil,
+        # Media type (refine)
+        media_type: nil,
+        # Cached style username for voice matching (compose)
+        style_username: nil,
+        # Desired tone (refine)
+        tone: nil,
+        # Tweet topic (compose, refine)
+        topic: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            step: XTwitterScraper::ComposeCreateParams::Step::OrSymbol,
+            additional_context: String,
+            call_to_action: String,
+            draft: String,
+            goal: XTwitterScraper::ComposeCreateParams::Goal::OrSymbol,
+            has_link: T::Boolean,
+            has_media: T::Boolean,
+            media_type:
+              XTwitterScraper::ComposeCreateParams::MediaType::OrSymbol,
+            style_username: String,
+            tone: String,
+            topic: String,
+            request_options: XTwitterScraper::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Workflow step
+      module Step
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, XTwitterScraper::ComposeCreateParams::Step)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        COMPOSE =
+          T.let(
+            :compose,
+            XTwitterScraper::ComposeCreateParams::Step::TaggedSymbol
+          )
+        REFINE =
+          T.let(
+            :refine,
+            XTwitterScraper::ComposeCreateParams::Step::TaggedSymbol
+          )
+        SCORE =
+          T.let(
+            :score,
+            XTwitterScraper::ComposeCreateParams::Step::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[XTwitterScraper::ComposeCreateParams::Step::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Optimization goal
+      module Goal
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, XTwitterScraper::ComposeCreateParams::Goal)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ENGAGEMENT =
+          T.let(
+            :engagement,
+            XTwitterScraper::ComposeCreateParams::Goal::TaggedSymbol
+          )
+        FOLLOWERS =
+          T.let(
+            :followers,
+            XTwitterScraper::ComposeCreateParams::Goal::TaggedSymbol
+          )
+        AUTHORITY =
+          T.let(
+            :authority,
+            XTwitterScraper::ComposeCreateParams::Goal::TaggedSymbol
+          )
+        CONVERSATION =
+          T.let(
+            :conversation,
+            XTwitterScraper::ComposeCreateParams::Goal::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[XTwitterScraper::ComposeCreateParams::Goal::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Media type (refine)
+      module MediaType
+        extend XTwitterScraper::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, XTwitterScraper::ComposeCreateParams::MediaType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PHOTO =
+          T.let(
+            :photo,
+            XTwitterScraper::ComposeCreateParams::MediaType::TaggedSymbol
+          )
+        VIDEO =
+          T.let(
+            :video,
+            XTwitterScraper::ComposeCreateParams::MediaType::TaggedSymbol
+          )
+        NONE =
+          T.let(
+            :none,
+            XTwitterScraper::ComposeCreateParams::MediaType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              XTwitterScraper::ComposeCreateParams::MediaType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/compose_create_response.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class ComposeCreateResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::ComposeCreateResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      # AI feedback on the draft
+      sig { returns(T.nilable(String)) }
+      attr_reader :feedback
+
+      sig { params(feedback: String).void }
+      attr_writer :feedback
+
+      # Engagement score (0-100)
+      sig { returns(T.nilable(Float)) }
+      attr_reader :score
+
+      sig { params(score: Float).void }
+      attr_writer :score
+
+      # Improvement suggestions
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :suggestions
+
+      sig { params(suggestions: T::Array[String]).void }
+      attr_writer :suggestions
+
+      # Generated or refined tweet text
+      sig { returns(T.nilable(String)) }
+      attr_reader :text
+
+      sig { params(text: String).void }
+      attr_writer :text
+
+      sig do
+        params(
+          feedback: String,
+          score: Float,
+          suggestions: T::Array[String],
+          text: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # AI feedback on the draft
+        feedback: nil,
+        # Engagement score (0-100)
+        score: nil,
+        # Improvement suggestions
+        suggestions: nil,
+        # Generated or refined tweet text
+        text: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            feedback: String,
+            score: Float,
+            suggestions: T::Array[String],
+            text: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/credit_retrieve_balance_params.rbi

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

data/rbi/x_twitter_scraper/models/credit_retrieve_balance_response.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class CreditRetrieveBalanceResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::CreditRetrieveBalanceResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :auto_topup_enabled
+
+      sig { returns(Integer) }
+      attr_accessor :balance
+
+      sig { returns(Integer) }
+      attr_accessor :lifetime_purchased
+
+      sig { returns(Integer) }
+      attr_accessor :lifetime_used
+
+      sig do
+        params(
+          auto_topup_enabled: T::Boolean,
+          balance: Integer,
+          lifetime_purchased: Integer,
+          lifetime_used: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        auto_topup_enabled:,
+        balance:,
+        lifetime_purchased:,
+        lifetime_used:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            auto_topup_enabled: T::Boolean,
+            balance: Integer,
+            lifetime_purchased: Integer,
+            lifetime_used: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/credit_topup_balance_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class CreditTopupBalanceParams < XTwitterScraper::Internal::Type::BaseModel
+      extend XTwitterScraper::Internal::Type::RequestParameters::Converter
+      include XTwitterScraper::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::CreditTopupBalanceParams,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      # Amount to top up in credits
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      sig do
+        params(
+          amount: Integer,
+          request_options: XTwitterScraper::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Amount to top up in credits
+        amount:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { amount: Integer, request_options: XTwitterScraper::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/credit_topup_balance_response.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class CreditTopupBalanceResponse < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            XTwitterScraper::Models::CreditTopupBalanceResponse,
+            XTwitterScraper::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      sig { params(success: T::Boolean).returns(T.attached_class) }
+      def self.new(success: true)
+      end
+
+      sig { override.returns({ success: T::Boolean }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/delivery.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class Delivery < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(XTwitterScraper::Delivery, XTwitterScraper::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(Integer) }
+      attr_accessor :attempts
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(String) }
+      attr_accessor :status
+
+      sig { returns(String) }
+      attr_accessor :stream_event_id
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :delivered_at
+
+      sig { params(delivered_at: Time).void }
+      attr_writer :delivered_at
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :last_error
+
+      sig { params(last_error: String).void }
+      attr_writer :last_error
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :last_status_code
+
+      sig { params(last_status_code: Integer).void }
+      attr_writer :last_status_code
+
+      sig do
+        params(
+          id: String,
+          attempts: Integer,
+          created_at: Time,
+          status: String,
+          stream_event_id: String,
+          delivered_at: Time,
+          last_error: String,
+          last_status_code: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        attempts:,
+        created_at:,
+        status:,
+        stream_event_id:,
+        delivered_at: nil,
+        last_error: nil,
+        last_status_code: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            attempts: Integer,
+            created_at: Time,
+            status: String,
+            stream_event_id: String,
+            delivered_at: Time,
+            last_error: String,
+            last_status_code: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/models/draft.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module XTwitterScraper
+  module Models
+    class Draft < XTwitterScraper::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(XTwitterScraper::Draft, XTwitterScraper::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(String) }
+      attr_accessor :text
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :goal
+
+      sig { params(goal: String).void }
+      attr_writer :goal
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :topic
+
+      sig { params(topic: String).void }
+      attr_writer :topic
+
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          text: String,
+          goal: String,
+          topic: String
+        ).returns(T.attached_class)
+      end
+      def self.new(id:, created_at:, text:, goal: nil, topic: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            text: String,
+            goal: String,
+            topic: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end