x-twitter-scraper 0.4.5 → 0.5.2

data/rbi/x_twitter_scraper/models/compose_create_response.rbi

@@ -2,74 +2,563 @@
 
 module XTwitterScraper
   module Models
-    class ComposeCreateResponse < XTwitterScraper::Internal::Type::BaseModel
-      OrHash =
+    module ComposeCreateResponse
+      extend XTwitterScraper::Internal::Type::Union
+
+      Variants =
         T.type_alias do
           T.any(
-            XTwitterScraper::Models::ComposeCreateResponse,
-            XTwitterScraper::Internal::AnyHash
+            XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult,
+            XTwitterScraper::Models::ComposeCreateResponse::ComposeRefineResult,
+            XTwitterScraper::Models::ComposeCreateResponse::ComposeScoreResult
           )
         end
 
-      # AI feedback on the draft
-      sig { returns(T.nilable(String)) }
-      attr_reader :feedback
+      class ComposePrepareResult < XTwitterScraper::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult,
+              XTwitterScraper::Internal::AnyHash
+            )
+          end
 
-      sig { params(feedback: String).void }
-      attr_writer :feedback
+        # Xquik editorial heuristics, ordered for the goal.
+        sig do
+          returns(
+            T::Array[
+              XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ContentRule
+            ]
+          )
+        end
+        attr_accessor :content_rules
 
-      # Engagement score (0-100)
-      sig { returns(T.nilable(Float)) }
-      attr_reader :score
+        # Published engagement signal names. Production multipliers are not published.
+        sig do
+          returns(
+            T::Array[
+              XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::EngagementMultiplier
+            ]
+          )
+        end
+        attr_accessor :engagement_multipliers
 
-      sig { params(score: Float).void }
-      attr_writer :score
+        # Publication limit for timing and decay claims.
+        sig { returns(String) }
+        attr_accessor :engagement_velocity
 
-      # Improvement suggestions
-      sig { returns(T.nilable(T::Array[String])) }
-      attr_reader :suggestions
+        sig { returns(T::Array[String]) }
+        attr_accessor :follow_up_questions
 
-      sig { params(suggestions: T::Array[String]).void }
-      attr_writer :suggestions
+        # X post intent seeded with the topic.
+        sig { returns(String) }
+        attr_accessor :intent_url
 
-      # Generated or refined tweet text
-      sig { returns(T.nilable(String)) }
-      attr_reader :text
+        sig { returns(String) }
+        attr_accessor :next_step
 
-      sig { params(text: String).void }
-      attr_writer :text
+        # Published signal names with unpublished weights as null.
+        sig do
+          returns(
+            T::Array[
+              XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ScorerWeight
+            ]
+          )
+        end
+        attr_accessor :scorer_weights
 
-      sig do
-        params(
-          feedback: String,
-          score: Float,
-          suggestions: T::Array[String],
-          text: String
-        ).returns(T.attached_class)
+        # Signal source and evidence limits.
+        sig { returns(String) }
+        attr_accessor :source
+
+        # Negative engagement predictions in the public model.
+        sig { returns(T::Array[String]) }
+        attr_accessor :top_penalties
+
+        # Style analyses saved to the account.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::SavedStyle
+              ]
+            )
+          )
+        end
+        attr_reader :saved_styles
+
+        sig do
+          params(
+            saved_styles:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::SavedStyle::OrHash
+              ]
+          ).void
+        end
+        attr_writer :saved_styles
+
+        # Next action when no cached style is available.
+        sig { returns(T.nilable(String)) }
+        attr_reader :style_note
+
+        sig { params(style_note: String).void }
+        attr_writer :style_note
+
+        # Cached examples for the requested style username.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :style_tweets
+
+        sig { params(style_tweets: T::Array[String]).void }
+        attr_writer :style_tweets
+
+        sig do
+          params(
+            content_rules:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ContentRule::OrHash
+              ],
+            engagement_multipliers:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::EngagementMultiplier::OrHash
+              ],
+            engagement_velocity: String,
+            follow_up_questions: T::Array[String],
+            intent_url: String,
+            next_step: String,
+            scorer_weights:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ScorerWeight::OrHash
+              ],
+            source: String,
+            top_penalties: T::Array[String],
+            saved_styles:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::SavedStyle::OrHash
+              ],
+            style_note: String,
+            style_tweets: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Xquik editorial heuristics, ordered for the goal.
+          content_rules:,
+          # Published engagement signal names. Production multipliers are not published.
+          engagement_multipliers:,
+          # Publication limit for timing and decay claims.
+          engagement_velocity:,
+          follow_up_questions:,
+          # X post intent seeded with the topic.
+          intent_url:,
+          next_step:,
+          # Published signal names with unpublished weights as null.
+          scorer_weights:,
+          # Signal source and evidence limits.
+          source:,
+          # Negative engagement predictions in the public model.
+          top_penalties:,
+          # Style analyses saved to the account.
+          saved_styles: nil,
+          # Next action when no cached style is available.
+          style_note: nil,
+          # Cached examples for the requested style username.
+          style_tweets: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content_rules:
+                T::Array[
+                  XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ContentRule
+                ],
+              engagement_multipliers:
+                T::Array[
+                  XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::EngagementMultiplier
+                ],
+              engagement_velocity: String,
+              follow_up_questions: T::Array[String],
+              intent_url: String,
+              next_step: String,
+              scorer_weights:
+                T::Array[
+                  XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ScorerWeight
+                ],
+              source: String,
+              top_penalties: T::Array[String],
+              saved_styles:
+                T::Array[
+                  XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::SavedStyle
+                ],
+              style_note: String,
+              style_tweets: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ContentRule < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ContentRule,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :rule
+
+          sig { params(rule: String).returns(T.attached_class) }
+          def self.new(rule:)
+          end
+
+          sig { override.returns({ rule: String }) }
+          def to_hash
+          end
+        end
+
+        class EngagementMultiplier < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::EngagementMultiplier,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          # Human-readable published signal name.
+          sig { returns(String) }
+          attr_accessor :action
+
+          sig { returns(Symbol) }
+          attr_accessor :multiplier
+
+          sig do
+            params(action: String, multiplier: Symbol).returns(T.attached_class)
+          end
+          def self.new(
+            # Human-readable published signal name.
+            action:,
+            multiplier: :"Production weight not published by X"
+          )
+          end
+
+          sig { override.returns({ action: String, multiplier: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class ScorerWeight < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::ScorerWeight,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          # Signal direction and publication limit.
+          sig { returns(String) }
+          attr_accessor :context
+
+          # Signal name from X's public ranking repository.
+          sig { returns(String) }
+          attr_accessor :signal
+
+          # X does not publish the production weight.
+          sig { returns(NilClass) }
+          attr_accessor :weight
+
+          sig do
+            params(context: String, signal: String, weight: NilClass).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # Signal direction and publication limit.
+            context:,
+            # Signal name from X's public ranking repository.
+            signal:,
+            # X does not publish the production weight.
+            weight:
+          )
+          end
+
+          sig do
+            override.returns(
+              { context: String, signal: String, weight: NilClass }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class SavedStyle < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::ComposeCreateResponse::ComposePrepareResult::SavedStyle,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Integer) }
+          attr_accessor :tweet_count
+
+          sig { returns(String) }
+          attr_accessor :username
+
+          sig do
+            params(tweet_count: Integer, username: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(tweet_count:, username:)
+          end
+
+          sig { override.returns({ tweet_count: Integer, username: String }) }
+          def to_hash
+          end
+        end
+      end
+
+      class ComposeRefineResult < XTwitterScraper::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::Models::ComposeCreateResponse::ComposeRefineResult,
+              XTwitterScraper::Internal::AnyHash
+            )
+          end
+
+        # Goal, tone, media, and editorial guidance.
+        sig { returns(T::Array[String]) }
+        attr_accessor :composition_guidance
+
+        sig do
+          returns(
+            T::Array[
+              XTwitterScraper::Models::ComposeCreateResponse::ComposeRefineResult::ExamplePattern
+            ]
+          )
+        end
+        attr_accessor :example_patterns
+
+        # X post intent seeded with the topic.
+        sig { returns(String) }
+        attr_accessor :intent_url
+
+        sig { returns(String) }
+        attr_accessor :next_step
+
+        sig do
+          params(
+            composition_guidance: T::Array[String],
+            example_patterns:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposeRefineResult::ExamplePattern::OrHash
+              ],
+            intent_url: String,
+            next_step: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Goal, tone, media, and editorial guidance.
+          composition_guidance:,
+          example_patterns:,
+          # X post intent seeded with the topic.
+          intent_url:,
+          next_step:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              composition_guidance: T::Array[String],
+              example_patterns:
+                T::Array[
+                  XTwitterScraper::Models::ComposeCreateResponse::ComposeRefineResult::ExamplePattern
+                ],
+              intent_url: String,
+              next_step: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ExamplePattern < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::ComposeCreateResponse::ComposeRefineResult::ExamplePattern,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :description
+
+          sig { returns(String) }
+          attr_accessor :pattern
+
+          sig do
+            params(description: String, pattern: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(description:, pattern:)
+          end
+
+          sig { override.returns({ description: String, pattern: String }) }
+          def to_hash
+          end
+        end
       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
-      )
+
+      class ComposeScoreResult < XTwitterScraper::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::Models::ComposeCreateResponse::ComposeScoreResult,
+              XTwitterScraper::Internal::AnyHash
+            )
+          end
+
+        # Deterministic editorial checks. Not a reach prediction.
+        sig do
+          returns(
+            T::Array[
+              XTwitterScraper::Models::ComposeCreateResponse::ComposeScoreResult::Checklist
+            ]
+          )
+        end
+        attr_accessor :checklist
+
+        sig { returns(String) }
+        attr_accessor :next_step
+
+        sig { returns(T::Boolean) }
+        attr_accessor :passed
+
+        sig { returns(Integer) }
+        attr_accessor :passed_count
+
+        sig { returns(String) }
+        attr_accessor :top_suggestion
+
+        sig { returns(Integer) }
+        attr_accessor :total_checks
+
+        # Present only when every check passes.
+        sig { returns(T.nilable(String)) }
+        attr_reader :intent_url
+
+        sig { params(intent_url: String).void }
+        attr_writer :intent_url
+
+        sig do
+          params(
+            checklist:
+              T::Array[
+                XTwitterScraper::Models::ComposeCreateResponse::ComposeScoreResult::Checklist::OrHash
+              ],
+            next_step: String,
+            passed: T::Boolean,
+            passed_count: Integer,
+            top_suggestion: String,
+            intent_url: String,
+            total_checks: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Deterministic editorial checks. Not a reach prediction.
+          checklist:,
+          next_step:,
+          passed:,
+          passed_count:,
+          top_suggestion:,
+          # Present only when every check passes.
+          intent_url: nil,
+          total_checks: 9
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              checklist:
+                T::Array[
+                  XTwitterScraper::Models::ComposeCreateResponse::ComposeScoreResult::Checklist
+                ],
+              next_step: String,
+              passed: T::Boolean,
+              passed_count: Integer,
+              top_suggestion: String,
+              total_checks: Integer,
+              intent_url: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Checklist < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::ComposeCreateResponse::ComposeScoreResult::Checklist,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :factor
+
+          sig { returns(T::Boolean) }
+          attr_accessor :passed
+
+          # Present only when the check fails.
+          sig { returns(T.nilable(String)) }
+          attr_reader :suggestion
+
+          sig { params(suggestion: String).void }
+          attr_writer :suggestion
+
+          sig do
+            params(
+              factor: String,
+              passed: T::Boolean,
+              suggestion: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            factor:,
+            passed:,
+            # Present only when the check fails.
+            suggestion: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              { factor: String, passed: T::Boolean, suggestion: String }
+            )
+          end
+          def to_hash
+          end
+        end
       end
 
       sig do
         override.returns(
-          {
-            feedback: String,
-            score: Float,
-            suggestions: T::Array[String],
-            text: String
-          }
+          T::Array[XTwitterScraper::Models::ComposeCreateResponse::Variants]
         )
       end
-      def to_hash
+      def self.variants
       end
     end
   end

data/rbi/x_twitter_scraper/models/credit_retrieve_topup_status_params.rbi

@@ -14,7 +14,7 @@ module XTwitterScraper
           )
         end
 
-      # Billing session ID returned by the top-up billing flow.
+      # Top-up session ID to inspect.
       sig { returns(String) }
       attr_accessor :session_id
 
@@ -25,7 +25,7 @@ module XTwitterScraper
         ).returns(T.attached_class)
       end
       def self.new(
-        # Billing session ID returned by the top-up billing flow.
+        # Top-up session ID to inspect.
         session_id:,
         request_options: {}
       )