x-twitter-scraper 0.4.5 → 0.5.2

data/rbi/x_twitter_scraper/models/x/write_action_retrieve_response.rbi

@@ -13,35 +13,128 @@ module XTwitterScraper
           end
 
         sig { returns(String) }
+        attr_accessor :id
+
+        # Connected account selected for the write.
+        sig do
+          returns(
+            T.nilable(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Account
+            )
+          )
+        end
+        attr_reader :account
+
+        sig do
+          params(
+            account:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Account::OrHash
+              )
+          ).void
+        end
+        attr_writer :account
+
+        sig do
+          returns(
+            XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+          )
+        end
         attr_accessor :action
 
+        # plannedCredits is the approved maximum. chargedCredits comes from the settled
+        # credit ledger. Pending or failed writes are not charged.
+        sig do
+          returns(
+            XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing
+          )
+        end
+        attr_reader :billing
+
+        sig do
+          params(
+            billing:
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::OrHash
+          ).void
+        end
+        attr_writer :billing
+
         sig { returns(T::Boolean) }
         attr_accessor :charged
 
         sig { returns(String) }
         attr_accessor :charged_credits
 
-        sig { returns(Time) }
-        attr_accessor :created_at
+        # Exact follow-up an API client or agent should perform.
+        sig do
+          returns(
+            T.nilable(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction
+            )
+          )
+        end
+        attr_reader :next_action
+
+        sig do
+          params(
+            next_action:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::OrHash
+              )
+          ).void
+        end
+        attr_writer :next_action
+
+        sig { returns(Symbol) }
+        attr_accessor :object
 
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :poll_after_ms
+
+        # Stable fingerprint and sanitized payload for replay checks.
         sig do
           returns(
-            XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media
+            XTwitterScraper::Models::X::WriteActionRetrieveResponse::Request
           )
         end
-        attr_reader :media
+        attr_reader :request
 
         sig do
           params(
-            media:
-              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::OrHash
+            request:
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Request::OrHash
           ).void
         end
-        attr_writer :media
+        attr_writer :request
+
+        # Confirmed result produced by the write, when available.
+        sig do
+          returns(
+            T.nilable(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result
+            )
+          )
+        end
+        attr_reader :result
 
+        sig do
+          params(
+            result:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::OrHash
+              )
+          ).void
+        end
+        attr_writer :result
+
+        # True only when a new attempt can reasonably succeed.
         sig { returns(T::Boolean) }
         attr_accessor :retryable
 
+        # True only when no write was dispatched and a new idempotency key may be used.
+        sig { returns(T::Boolean) }
+        attr_accessor :safe_to_retry
+
         sig { returns(T::Boolean) }
         attr_accessor :send_dispatched
 
@@ -52,9 +145,61 @@ module XTwitterScraper
         end
         attr_accessor :status
 
+        sig { returns(String) }
+        attr_accessor :status_url
+
+        sig { returns(T::Boolean) }
+        attr_accessor :success
+
+        # Existing X resource targeted by the write, when applicable.
+        sig do
+          returns(
+            T.nilable(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target
+            )
+          )
+        end
+        attr_reader :target
+
+        sig do
+          params(
+            target:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::OrHash
+              )
+          ).void
+        end
+        attr_writer :target
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :target_id
+
+        sig { returns(T::Boolean) }
+        attr_accessor :terminal
+
         sig { returns(String) }
         attr_accessor :write_action_id
 
+        # Compatibility field for a confirmed community ID.
+        sig { returns(T.nilable(String)) }
+        attr_reader :community_id
+
+        sig { params(community_id: String).void }
+        attr_writer :community_id
+
+        # Confirmed community name when available.
+        sig { returns(T.nilable(String)) }
+        attr_reader :community_name
+
+        sig { params(community_name: String).void }
+        attr_writer :community_name
+
+        sig { returns(T.nilable(Time)) }
+        attr_reader :completed_at
+
+        sig { params(completed_at: Time).void }
+        attr_writer :completed_at
+
         sig { returns(T.nilable(Integer)) }
         attr_reader :confirmation_attempts
 
@@ -67,200 +212,822 @@ module XTwitterScraper
         sig { params(confirmation_checked_at: Time).void }
         attr_writer :confirmation_checked_at
 
-        sig { returns(T.nilable(String)) }
-        attr_accessor :confirmation_source
-
         sig { returns(T.nilable(Time)) }
         attr_reader :confirmed_at
 
         sig { params(confirmed_at: Time).void }
         attr_writer :confirmed_at
 
+        sig { returns(T.nilable(Time)) }
+        attr_reader :created_at
+
+        sig { params(created_at: Time).void }
+        attr_writer :created_at
+
+        # Structured recovery context for a failed write.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :details
+
+        sig { params(details: T::Hash[Symbol, T.anything]).void }
+        attr_writer :details
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :error
+
+        sig { params(error: String).void }
+        attr_writer :error
+
+        # Deadline for resolving a non-terminal write. This is not the Idempotency-Key
+        # retention deadline.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :expires_at
+
+        sig { params(expires_at: Time).void }
+        attr_writer :expires_at
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :idempotent
+
+        sig { params(idempotent: T::Boolean).void }
+        attr_writer :idempotent
+
+        # Media count, kind, size, and billing details when used.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :media
+
+        sig { params(media: T::Hash[Symbol, T.anything]).void }
+        attr_writer :media
+
+        # Compatibility field for a confirmed media upload ID.
+        sig { returns(T.nilable(String)) }
+        attr_reader :media_id
+
+        sig { params(media_id: String).void }
+        attr_writer :media_id
+
+        # Public media URL when the upload creates one.
+        sig { returns(T.nilable(String)) }
+        attr_reader :media_url
+
+        sig { params(media_url: String).void }
+        attr_writer :media_url
+
         sig { returns(T.nilable(String)) }
         attr_reader :message
 
         sig { params(message: String).void }
         attr_writer :message
 
+        # Compatibility field for a confirmed direct message ID.
         sig { returns(T.nilable(String)) }
         attr_reader :message_id
 
         sig { params(message_id: String).void }
         attr_writer :message_id
 
+        sig { returns(T.nilable(String)) }
+        attr_reader :request_hash
+
+        sig { params(request_hash: String).void }
+        attr_writer :request_hash
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :request_id
+
+        sig { params(request_id: String).void }
+        attr_writer :request_id
+
+        # Compatibility result ID for other write actions.
+        sig { returns(T.nilable(String)) }
+        attr_reader :result_id
+
+        sig { params(result_id: String).void }
+        attr_writer :result_id
+
+        # Dispatch timestamp when the write reached execution.
         sig { returns(T.nilable(Time)) }
         attr_reader :send_dispatched_at
 
         sig { params(send_dispatched_at: Time).void }
         attr_writer :send_dispatched_at
 
-        sig { returns(T.nilable(String)) }
-        attr_accessor :target_id
-
+        # Compatibility field for a confirmed tweet result ID.
         sig { returns(T.nilable(String)) }
         attr_reader :tweet_id
 
         sig { params(tweet_id: String).void }
         attr_writer :tweet_id
 
+        sig { returns(T.nilable(Time)) }
+        attr_reader :updated_at
+
+        sig { params(updated_at: Time).void }
+        attr_writer :updated_at
+
+        # Durable write lifecycle record. Poll statusUrl until terminal is true. Reusing
+        # the original Idempotency-Key returns this same record. Submit a new write only
+        # when safeToRetry is true, using a new key.
         sig do
           params(
-            action: String,
+            id: String,
+            account:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Account::OrHash
+              ),
+            action:
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::OrSymbol,
+            billing:
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::OrHash,
             charged: T::Boolean,
             charged_credits: String,
-            created_at: Time,
-            media:
-              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::OrHash,
+            next_action:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::OrHash
+              ),
+            poll_after_ms: T.nilable(Integer),
+            request:
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Request::OrHash,
+            result:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::OrHash
+              ),
+            retryable: T::Boolean,
+            safe_to_retry: T::Boolean,
             send_dispatched: T::Boolean,
             status:
               XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::OrSymbol,
+            status_url: String,
+            success: T::Boolean,
+            target:
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::OrHash
+              ),
+            target_id: T.nilable(String),
+            terminal: T::Boolean,
             write_action_id: String,
+            community_id: String,
+            community_name: String,
+            completed_at: Time,
             confirmation_attempts: Integer,
             confirmation_checked_at: Time,
-            confirmation_source: T.nilable(String),
             confirmed_at: Time,
+            created_at: Time,
+            details: T::Hash[Symbol, T.anything],
+            error: String,
+            expires_at: Time,
+            idempotent: T::Boolean,
+            media: T::Hash[Symbol, T.anything],
+            media_id: String,
+            media_url: String,
             message: String,
             message_id: String,
+            request_hash: String,
+            request_id: String,
+            result_id: String,
             send_dispatched_at: Time,
-            target_id: T.nilable(String),
             tweet_id: String,
-            retryable: T::Boolean
+            updated_at: Time,
+            object: Symbol
           ).returns(T.attached_class)
         end
         def self.new(
+          id:,
+          # Connected account selected for the write.
+          account:,
           action:,
+          # plannedCredits is the approved maximum. chargedCredits comes from the settled
+          # credit ledger. Pending or failed writes are not charged.
+          billing:,
           charged:,
           charged_credits:,
-          created_at:,
-          media:,
+          # Exact follow-up an API client or agent should perform.
+          next_action:,
+          poll_after_ms:,
+          # Stable fingerprint and sanitized payload for replay checks.
+          request:,
+          # Confirmed result produced by the write, when available.
+          result:,
+          # True only when a new attempt can reasonably succeed.
+          retryable:,
+          # True only when no write was dispatched and a new idempotency key may be used.
+          safe_to_retry:,
           send_dispatched:,
           status:,
+          status_url:,
+          success:,
+          # Existing X resource targeted by the write, when applicable.
+          target:,
+          target_id:,
+          terminal:,
           write_action_id:,
+          # Compatibility field for a confirmed community ID.
+          community_id: nil,
+          # Confirmed community name when available.
+          community_name: nil,
+          completed_at: nil,
           confirmation_attempts: nil,
           confirmation_checked_at: nil,
-          confirmation_source: nil,
           confirmed_at: nil,
+          created_at: nil,
+          # Structured recovery context for a failed write.
+          details: nil,
+          error: nil,
+          # Deadline for resolving a non-terminal write. This is not the Idempotency-Key
+          # retention deadline.
+          expires_at: nil,
+          idempotent: nil,
+          # Media count, kind, size, and billing details when used.
+          media: nil,
+          # Compatibility field for a confirmed media upload ID.
+          media_id: nil,
+          # Public media URL when the upload creates one.
+          media_url: nil,
           message: nil,
+          # Compatibility field for a confirmed direct message ID.
           message_id: nil,
+          request_hash: nil,
+          request_id: nil,
+          # Compatibility result ID for other write actions.
+          result_id: nil,
+          # Dispatch timestamp when the write reached execution.
           send_dispatched_at: nil,
-          target_id: nil,
+          # Compatibility field for a confirmed tweet result ID.
           tweet_id: nil,
-          retryable: false
+          updated_at: nil,
+          object: :x_write_action
         )
         end
 
         sig do
           override.returns(
             {
-              action: String,
+              id: String,
+              account:
+                T.nilable(
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Account
+                ),
+              action:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol,
+              billing:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing,
               charged: T::Boolean,
               charged_credits: String,
-              created_at: Time,
-              media:
-                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media,
+              next_action:
+                T.nilable(
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction
+                ),
+              object: Symbol,
+              poll_after_ms: T.nilable(Integer),
+              request:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Request,
+              result:
+                T.nilable(
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result
+                ),
               retryable: T::Boolean,
+              safe_to_retry: T::Boolean,
               send_dispatched: T::Boolean,
               status:
                 XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::TaggedSymbol,
+              status_url: String,
+              success: T::Boolean,
+              target:
+                T.nilable(
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target
+                ),
+              target_id: T.nilable(String),
+              terminal: T::Boolean,
               write_action_id: String,
+              community_id: String,
+              community_name: String,
+              completed_at: Time,
               confirmation_attempts: Integer,
               confirmation_checked_at: Time,
-              confirmation_source: T.nilable(String),
               confirmed_at: Time,
+              created_at: Time,
+              details: T::Hash[Symbol, T.anything],
+              error: String,
+              expires_at: Time,
+              idempotent: T::Boolean,
+              media: T::Hash[Symbol, T.anything],
+              media_id: String,
+              media_url: String,
               message: String,
               message_id: String,
+              request_hash: String,
+              request_id: String,
+              result_id: String,
               send_dispatched_at: Time,
-              target_id: T.nilable(String),
-              tweet_id: String
+              tweet_id: String,
+              updated_at: Time
             }
           )
         end
         def to_hash
         end
 
-        class Media < XTwitterScraper::Internal::Type::BaseModel
+        class Account < XTwitterScraper::Internal::Type::BaseModel
           OrHash =
             T.type_alias do
               T.any(
-                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Account,
                 XTwitterScraper::Internal::AnyHash
               )
             end
 
-          sig { returns(Integer) }
-          attr_accessor :count
+          sig { returns(String) }
+          attr_accessor :id
 
           sig { returns(String) }
-          attr_accessor :credits
+          attr_accessor :username
+
+          # Connected account selected for the write.
+          sig { params(id: String, username: String).returns(T.attached_class) }
+          def self.new(id:, username:)
+          end
+
+          sig { override.returns({ id: String, username: String }) }
+          def to_hash
+          end
+        end
+
+        module Action
+          extend XTwitterScraper::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CREATE_TWEET =
+            T.let(
+              :create_tweet,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          DELETE_TWEET =
+            T.let(
+              :delete_tweet,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          LIKE =
+            T.let(
+              :like,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UNLIKE =
+            T.let(
+              :unlike,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          RETWEET =
+            T.let(
+              :retweet,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UNRETWEET =
+            T.let(
+              :unretweet,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          FOLLOW =
+            T.let(
+              :follow,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UNFOLLOW =
+            T.let(
+              :unfollow,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          REMOVE_FOLLOWER =
+            T.let(
+              :remove_follower,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          SEND_DM =
+            T.let(
+              :send_dm,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UPLOAD_MEDIA =
+            T.let(
+              :upload_media,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UPDATE_PROFILE =
+            T.let(
+              :update_profile,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UPDATE_AVATAR =
+            T.let(
+              :update_avatar,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          UPDATE_BANNER =
+            T.let(
+              :update_banner,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          CREATE_COMMUNITY =
+            T.let(
+              :create_community,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          DELETE_COMMUNITY =
+            T.let(
+              :delete_community,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          JOIN_COMMUNITY =
+            T.let(
+              :join_community,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
+          LEAVE_COMMUNITY =
+            T.let(
+              :leave_community,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+            )
 
           sig do
-            returns(
-              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::TaggedSymbol
+            override.returns(
+              T::Array[
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Action::TaggedSymbol
+              ]
             )
           end
-          attr_accessor :kind
+          def self.values
+          end
+        end
+
+        class Billing < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T::Boolean) }
+          attr_accessor :charged
+
+          sig { returns(String) }
+          attr_accessor :charged_credits
 
           sig { returns(String) }
-          attr_accessor :total_bytes
+          attr_accessor :planned_credits
+
+          sig do
+            returns(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          # plannedCredits is the approved maximum. chargedCredits comes from the settled
+          # credit ledger. Pending or failed writes are not charged.
+          sig do
+            params(
+              charged: T::Boolean,
+              charged_credits: String,
+              planned_credits: String,
+              status:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(charged:, charged_credits:, planned_credits:, status:)
+          end
+
+          sig do
+            override.returns(
+              {
+                charged: T::Boolean,
+                charged_credits: String,
+                planned_credits: String,
+                status:
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Status
+            extend XTwitterScraper::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            NOT_CHARGED =
+              T.let(
+                :not_charged,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+              )
+            PENDING =
+              T.let(
+                :pending,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+              )
+            CHARGED =
+              T.let(
+                :charged,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+              )
+            CHARGE_FAILED =
+              T.let(
+                :charge_failed,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+              )
+            REFUNDED =
+              T.let(
+                :refunded,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Billing::Status::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class NextAction < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol
+            )
+          end
+          attr_accessor :type
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :after_ms
+
+          sig { params(after_ms: Integer).void }
+          attr_writer :after_ms
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :requires_new_idempotency_key
+
+          sig { params(requires_new_idempotency_key: T::Boolean).void }
+          attr_writer :requires_new_idempotency_key
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :url
+
+          sig { params(url: String).void }
+          attr_writer :url
 
+          # Exact follow-up an API client or agent should perform.
           sig do
             params(
-              count: Integer,
-              credits: String,
-              kind:
-                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::OrSymbol,
-              total_bytes: String
+              type:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::OrSymbol,
+              after_ms: Integer,
+              requires_new_idempotency_key: T::Boolean,
+              url: String
             ).returns(T.attached_class)
           end
-          def self.new(count:, credits:, kind:, total_bytes:)
+          def self.new(
+            type:,
+            after_ms: nil,
+            requires_new_idempotency_key: nil,
+            url: nil
+          )
           end
 
           sig do
             override.returns(
               {
-                count: Integer,
-                credits: String,
-                kind:
-                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::TaggedSymbol,
-                total_bytes: String
+                type:
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol,
+                after_ms: Integer,
+                requires_new_idempotency_key: T::Boolean,
+                url: String
               }
             )
           end
           def to_hash
           end
 
-          module Kind
+          module Type
             extend XTwitterScraper::Internal::Type::Enum
 
             TaggedSymbol =
               T.type_alias do
                 T.all(
                   Symbol,
-                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type
                 )
               end
             OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-            NONE =
+            POLL =
+              T.let(
+                :poll,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol
+              )
+            RETRY =
               T.let(
-                :none,
-                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::TaggedSymbol
+                :retry,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol
               )
-            IMAGE =
+            VERIFY_RESULT =
               T.let(
-                :image,
-                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::TaggedSymbol
+                :verify_result,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol
               )
-            VIDEO =
+            FIX_REQUEST =
               T.let(
-                :video,
-                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::TaggedSymbol
+                :fix_request,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol
               )
 
             sig do
               override.returns(
                 T::Array[
-                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Media::Kind::TaggedSymbol
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::NextAction::Type::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class Request < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Request,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          # Stable hash of account, action, target, and payload.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :hash_
+
+          # Exact sanitized payload dispatched for this action.
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_accessor :payload
+
+          # Stable fingerprint and sanitized payload for replay checks.
+          sig do
+            params(
+              hash_: T.nilable(String),
+              payload: T.nilable(T::Hash[Symbol, T.anything])
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Stable hash of account, action, target, and payload.
+            hash_:,
+            # Exact sanitized payload dispatched for this action.
+            payload:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                hash_: T.nilable(String),
+                payload: T.nilable(T::Hash[Symbol, T.anything])
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class Result < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :id
+
+          sig { params(id: String).void }
+          attr_writer :id
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :state
+
+          sig { params(state: String).void }
+          attr_writer :state
+
+          sig do
+            returns(
+              T.nilable(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :type
+
+          sig do
+            params(
+              type:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::OrSymbol
+            ).void
+          end
+          attr_writer :type
+
+          # Confirmed result produced by the write, when available.
+          sig do
+            params(
+              id: String,
+              state: String,
+              type:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(id: nil, state: nil, type: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                state: String,
+                type:
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Type
+            extend XTwitterScraper::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            TWEET =
+              T.let(
+                :tweet,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              )
+            DIRECT_MESSAGE =
+              T.let(
+                :direct_message,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              )
+            MEDIA =
+              T.let(
+                :media,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              )
+            COMMUNITY =
+              T.let(
+                :community,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              )
+            STATE_CHANGE =
+              T.let(
+                :state_change,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Result::Type::TaggedSymbol
                 ]
               )
             end
@@ -281,6 +1048,21 @@ module XTwitterScraper
             end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
+          ACCEPTED =
+            T.let(
+              :accepted,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::TaggedSymbol
+            )
+          DISPATCHING =
+            T.let(
+              :dispatching,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::TaggedSymbol
+            )
+          PENDING_CONFIRMATION =
+            T.let(
+              :pending_confirmation,
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::TaggedSymbol
+            )
           SUCCESS =
             T.let(
               :success,
@@ -291,9 +1073,9 @@ module XTwitterScraper
               :failed,
               XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::TaggedSymbol
             )
-          PENDING_CONFIRMATION =
+          EXPIRED =
             T.let(
-              :pending_confirmation,
+              :expired,
               XTwitterScraper::Models::X::WriteActionRetrieveResponse::Status::TaggedSymbol
             )
 
@@ -307,6 +1089,88 @@ module XTwitterScraper
           def self.values
           end
         end
+
+        class Target < XTwitterScraper::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target,
+                XTwitterScraper::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            returns(
+              XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::TaggedSymbol
+            )
+          end
+          attr_accessor :type
+
+          # Existing X resource targeted by the write, when applicable.
+          sig do
+            params(
+              id: String,
+              type:
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, type:)
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                type:
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Type
+            extend XTwitterScraper::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            TWEET =
+              T.let(
+                :tweet,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::TaggedSymbol
+              )
+            USER =
+              T.let(
+                :user,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::TaggedSymbol
+              )
+            COMMUNITY =
+              T.let(
+                :community,
+                XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  XTwitterScraper::Models::X::WriteActionRetrieveResponse::Target::Type::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
       end
     end
   end