onlyfans 0.2.0 → 0.3.0

data/rbi/onlyfans/models/media/vault/list_list_response.rbi

@@ -4,72 +4,23 @@ module Onlyfans
   module Models
     module Media
       module Vault
-        class ListListResponse < Onlyfans::Internal::Type::BaseModel
-          OrHash =
+        # Success
+        module ListListResponse
+          extend Onlyfans::Internal::Type::Union
+
+          Variants =
             T.type_alias do
               T.any(
-                Onlyfans::Models::Media::Vault::ListListResponse,
-                Onlyfans::Internal::AnyHash
+                Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0,
+                Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1
               )
             end
 
-          sig do
-            returns(
-              T.nilable(Onlyfans::Models::Media::Vault::ListListResponse::Meta)
-            )
-          end
-          attr_reader :_meta
-
-          sig do
-            params(
-              _meta:
-                Onlyfans::Models::Media::Vault::ListListResponse::Meta::OrHash
-            ).void
-          end
-          attr_writer :_meta
-
-          sig do
-            returns(
-              T.nilable(Onlyfans::Models::Media::Vault::ListListResponse::Data)
-            )
-          end
-          attr_reader :data
-
-          sig do
-            params(
-              data:
-                Onlyfans::Models::Media::Vault::ListListResponse::Data::OrHash
-            ).void
-          end
-          attr_writer :data
-
-          sig do
-            params(
-              _meta:
-                Onlyfans::Models::Media::Vault::ListListResponse::Meta::OrHash,
-              data:
-                Onlyfans::Models::Media::Vault::ListListResponse::Data::OrHash
-            ).returns(T.attached_class)
-          end
-          def self.new(_meta: nil, data: nil)
-          end
-
-          sig do
-            override.returns(
-              {
-                _meta: Onlyfans::Models::Media::Vault::ListListResponse::Meta,
-                data: Onlyfans::Models::Media::Vault::ListListResponse::Data
-              }
-            )
-          end
-          def to_hash
-          end
-
-          class Meta < Onlyfans::Internal::Type::BaseModel
+          class UnionMember0 < Onlyfans::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
                 T.any(
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta,
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0,
                   Onlyfans::Internal::AnyHash
                 )
               end
@@ -77,589 +28,1182 @@ module Onlyfans
             sig do
               returns(
                 T.nilable(
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::Cache
-                )
-              )
-            end
-            attr_reader :_cache
-
-            sig do
-              params(
-                _cache:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::Cache::OrHash
-              ).void
-            end
-            attr_writer :_cache
-
-            sig do
-              returns(
-                T.nilable(
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::Credits
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta
                 )
               )
             end
-            attr_reader :_credits
+            attr_reader :_meta
 
             sig do
               params(
-                _credits:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::Credits::OrHash
+                _meta:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::OrHash
               ).void
             end
-            attr_writer :_credits
+            attr_writer :_meta
 
             sig do
               returns(
                 T.nilable(
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::RateLimits
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data
                 )
               )
             end
-            attr_reader :_rate_limits
+            attr_reader :data
 
             sig do
               params(
-                _rate_limits:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::RateLimits::OrHash
+                data:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::OrHash
               ).void
             end
-            attr_writer :_rate_limits
+            attr_writer :data
 
+            # Success
             sig do
               params(
-                _cache:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::Cache::OrHash,
-                _credits:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::Credits::OrHash,
-                _rate_limits:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Meta::RateLimits::OrHash
+                _meta:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::OrHash,
+                data:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::OrHash
               ).returns(T.attached_class)
             end
-            def self.new(_cache: nil, _credits: nil, _rate_limits: nil)
+            def self.new(_meta: nil, data: nil)
             end
 
             sig do
               override.returns(
                 {
-                  _cache:
-                    Onlyfans::Models::Media::Vault::ListListResponse::Meta::Cache,
-                  _credits:
-                    Onlyfans::Models::Media::Vault::ListListResponse::Meta::Credits,
-                  _rate_limits:
-                    Onlyfans::Models::Media::Vault::ListListResponse::Meta::RateLimits
+                  _meta:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta,
+                  data:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data
                 }
               )
             end
             def to_hash
             end
 
-            class Cache < Onlyfans::Internal::Type::BaseModel
+            class Meta < Onlyfans::Internal::Type::BaseModel
               OrHash =
                 T.type_alias do
                   T.any(
-                    Onlyfans::Models::Media::Vault::ListListResponse::Meta::Cache,
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta,
                     Onlyfans::Internal::AnyHash
                   )
                 end
 
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_reader :is_cached
-
-              sig { params(is_cached: T::Boolean).void }
-              attr_writer :is_cached
-
-              sig { returns(T.nilable(String)) }
-              attr_reader :note
-
-              sig { params(note: String).void }
-              attr_writer :note
-
               sig do
-                params(is_cached: T::Boolean, note: String).returns(
-                  T.attached_class
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Cache
+                  )
                 )
               end
-              def self.new(is_cached: nil, note: nil)
-              end
+              attr_reader :_cache
 
-              sig { override.returns({ is_cached: T::Boolean, note: String }) }
-              def to_hash
+              sig do
+                params(
+                  _cache:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Cache::OrHash
+                ).void
               end
-            end
+              attr_writer :_cache
 
-            class Credits < Onlyfans::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    Onlyfans::Models::Media::Vault::ListListResponse::Meta::Credits,
-                    Onlyfans::Internal::AnyHash
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Credits
                   )
-                end
-
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :balance
-
-              sig { params(balance: Integer).void }
-              attr_writer :balance
-
-              sig { returns(T.nilable(String)) }
-              attr_reader :note
+                )
+              end
+              attr_reader :_credits
 
-              sig { params(note: String).void }
-              attr_writer :note
+              sig do
+                params(
+                  _credits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Credits::OrHash
+                ).void
+              end
+              attr_writer :_credits
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :used
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::RateLimits
+                  )
+                )
+              end
+              attr_reader :_rate_limits
 
-              sig { params(used: Integer).void }
-              attr_writer :used
+              sig do
+                params(
+                  _rate_limits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::RateLimits::OrHash
+                ).void
+              end
+              attr_writer :_rate_limits
 
               sig do
-                params(balance: Integer, note: String, used: Integer).returns(
-                  T.attached_class
-                )
+                params(
+                  _cache:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Cache::OrHash,
+                  _credits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Credits::OrHash,
+                  _rate_limits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::RateLimits::OrHash
+                ).returns(T.attached_class)
               end
-              def self.new(balance: nil, note: nil, used: nil)
+              def self.new(_cache: nil, _credits: nil, _rate_limits: nil)
               end
 
               sig do
                 override.returns(
-                  { balance: Integer, note: String, used: Integer }
+                  {
+                    _cache:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Cache,
+                    _credits:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Credits,
+                    _rate_limits:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::RateLimits
+                  }
                 )
               end
               def to_hash
               end
-            end
 
-            class RateLimits < Onlyfans::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    Onlyfans::Models::Media::Vault::ListListResponse::Meta::RateLimits,
-                    Onlyfans::Internal::AnyHash
-                  )
-                end
+              class Cache < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Cache,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :limit_day
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :is_cached
 
-              sig { params(limit_day: Integer).void }
-              attr_writer :limit_day
+                sig { params(is_cached: T::Boolean).void }
+                attr_writer :is_cached
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :limit_minute
+                sig { returns(T.nilable(String)) }
+                attr_reader :note
 
-              sig { params(limit_minute: Integer).void }
-              attr_writer :limit_minute
+                sig { params(note: String).void }
+                attr_writer :note
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :remaining_day
+                sig do
+                  params(is_cached: T::Boolean, note: String).returns(
+                    T.attached_class
+                  )
+                end
+                def self.new(is_cached: nil, note: nil)
+                end
 
-              sig { params(remaining_day: Integer).void }
-              attr_writer :remaining_day
+                sig do
+                  override.returns({ is_cached: T::Boolean, note: String })
+                end
+                def to_hash
+                end
+              end
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :remaining_minute
+              class Credits < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::Credits,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
 
-              sig { params(remaining_minute: Integer).void }
-              attr_writer :remaining_minute
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :balance
 
-              sig do
-                params(
-                  limit_day: Integer,
-                  limit_minute: Integer,
-                  remaining_day: Integer,
-                  remaining_minute: Integer
-                ).returns(T.attached_class)
-              end
-              def self.new(
-                limit_day: nil,
-                limit_minute: nil,
-                remaining_day: nil,
-                remaining_minute: nil
-              )
-              end
+                sig { params(balance: Integer).void }
+                attr_writer :balance
 
-              sig do
-                override.returns(
-                  {
-                    limit_day: Integer,
-                    limit_minute: Integer,
-                    remaining_day: Integer,
-                    remaining_minute: Integer
-                  }
-                )
-              end
-              def to_hash
-              end
-            end
-          end
+                sig { returns(T.nilable(String)) }
+                attr_reader :note
 
-          class Data < Onlyfans::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Onlyfans::Models::Media::Vault::ListListResponse::Data,
-                  Onlyfans::Internal::AnyHash
-                )
-              end
+                sig { params(note: String).void }
+                attr_writer :note
 
-            sig do
-              returns(
-                T.nilable(
-                  Onlyfans::Models::Media::Vault::ListListResponse::Data::All
-                )
-              )
-            end
-            attr_reader :all
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :used
 
-            sig do
-              params(
-                all:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Data::All::OrHash
-              ).void
-            end
-            attr_writer :all
+                sig { params(used: Integer).void }
+                attr_writer :used
 
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :can_create_vault_lists
+                sig do
+                  params(balance: Integer, note: String, used: Integer).returns(
+                    T.attached_class
+                  )
+                end
+                def self.new(balance: nil, note: nil, used: nil)
+                end
 
-            sig { params(can_create_vault_lists: T::Boolean).void }
-            attr_writer :can_create_vault_lists
+                sig do
+                  override.returns(
+                    { balance: Integer, note: String, used: Integer }
+                  )
+                end
+                def to_hash
+                end
+              end
 
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :has_more
+              class RateLimits < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Meta::RateLimits,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
 
-            sig { params(has_more: T::Boolean).void }
-            attr_writer :has_more
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :limit_day
 
-            sig do
-              returns(
-                T.nilable(
-                  T::Array[
-                    Onlyfans::Models::Media::Vault::ListListResponse::Data::List
-                  ]
-                )
-              )
-            end
-            attr_reader :list
+                sig { params(limit_day: Integer).void }
+                attr_writer :limit_day
 
-            sig do
-              params(
-                list:
-                  T::Array[
-                    Onlyfans::Models::Media::Vault::ListListResponse::Data::List::OrHash
-                  ]
-              ).void
-            end
-            attr_writer :list
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :limit_minute
 
-            sig { returns(T.nilable(String)) }
-            attr_reader :order
+                sig { params(limit_minute: Integer).void }
+                attr_writer :limit_minute
 
-            sig { params(order: String).void }
-            attr_writer :order
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :remaining_day
 
-            sig { returns(T.nilable(String)) }
-            attr_reader :sort
+                sig { params(remaining_day: Integer).void }
+                attr_writer :remaining_day
 
-            sig { params(sort: String).void }
-            attr_writer :sort
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :remaining_minute
 
-            sig do
-              params(
-                all:
-                  Onlyfans::Models::Media::Vault::ListListResponse::Data::All::OrHash,
-                can_create_vault_lists: T::Boolean,
-                has_more: T::Boolean,
-                list:
-                  T::Array[
-                    Onlyfans::Models::Media::Vault::ListListResponse::Data::List::OrHash
-                  ],
-                order: String,
-                sort: String
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              all: nil,
-              can_create_vault_lists: nil,
-              has_more: nil,
-              list: nil,
-              order: nil,
-              sort: nil
-            )
-            end
+                sig { params(remaining_minute: Integer).void }
+                attr_writer :remaining_minute
 
-            sig do
-              override.returns(
-                {
-                  all:
-                    Onlyfans::Models::Media::Vault::ListListResponse::Data::All,
-                  can_create_vault_lists: T::Boolean,
-                  has_more: T::Boolean,
-                  list:
-                    T::Array[
-                      Onlyfans::Models::Media::Vault::ListListResponse::Data::List
-                    ],
-                  order: String,
-                  sort: String
-                }
-              )
-            end
-            def to_hash
+                sig do
+                  params(
+                    limit_day: Integer,
+                    limit_minute: Integer,
+                    remaining_day: Integer,
+                    remaining_minute: Integer
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  limit_day: nil,
+                  limit_minute: nil,
+                  remaining_day: nil,
+                  remaining_minute: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      limit_day: Integer,
+                      limit_minute: Integer,
+                      remaining_day: Integer,
+                      remaining_minute: Integer
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
             end
 
-            class All < Onlyfans::Internal::Type::BaseModel
+            class Data < Onlyfans::Internal::Type::BaseModel
               OrHash =
                 T.type_alias do
                   T.any(
-                    Onlyfans::Models::Media::Vault::ListListResponse::Data::All,
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data,
                     Onlyfans::Internal::AnyHash
                   )
                 end
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :audios_count
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All
+                  )
+                )
+              end
+              attr_reader :all
+
+              sig do
+                params(
+                  all:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::OrHash
+                ).void
+              end
+              attr_writer :all
+
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_reader :can_create_vault_lists
 
-              sig { params(audios_count: Integer).void }
-              attr_writer :audios_count
+              sig { params(can_create_vault_lists: T::Boolean).void }
+              attr_writer :can_create_vault_lists
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :gifs_count
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_reader :has_more
 
-              sig { params(gifs_count: Integer).void }
-              attr_writer :gifs_count
+              sig { params(has_more: T::Boolean).void }
+              attr_writer :has_more
 
               sig do
                 returns(
                   T.nilable(
                     T::Array[
-                      Onlyfans::Models::Media::Vault::ListListResponse::Data::All::Media
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::List
                     ]
                   )
                 )
               end
-              attr_reader :medias
+              attr_reader :list
 
               sig do
                 params(
-                  medias:
+                  list:
                     T::Array[
-                      Onlyfans::Models::Media::Vault::ListListResponse::Data::All::Media::OrHash
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::List::OrHash
                     ]
                 ).void
               end
-              attr_writer :medias
+              attr_writer :list
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :photos_count
+              sig { returns(T.nilable(String)) }
+              attr_reader :order
 
-              sig { params(photos_count: Integer).void }
-              attr_writer :photos_count
+              sig { params(order: String).void }
+              attr_writer :order
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :videos_count
+              sig { returns(T.nilable(String)) }
+              attr_reader :sort
 
-              sig { params(videos_count: Integer).void }
-              attr_writer :videos_count
+              sig { params(sort: String).void }
+              attr_writer :sort
 
               sig do
                 params(
-                  audios_count: Integer,
-                  gifs_count: Integer,
-                  medias:
+                  all:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::OrHash,
+                  can_create_vault_lists: T::Boolean,
+                  has_more: T::Boolean,
+                  list:
                     T::Array[
-                      Onlyfans::Models::Media::Vault::ListListResponse::Data::All::Media::OrHash
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::List::OrHash
                     ],
-                  photos_count: Integer,
-                  videos_count: Integer
+                  order: String,
+                  sort: String
                 ).returns(T.attached_class)
               end
               def self.new(
-                audios_count: nil,
-                gifs_count: nil,
-                medias: nil,
-                photos_count: nil,
-                videos_count: nil
+                all: nil,
+                can_create_vault_lists: nil,
+                has_more: nil,
+                list: nil,
+                order: nil,
+                sort: nil
               )
               end
 
               sig do
                 override.returns(
                   {
-                    audios_count: Integer,
-                    gifs_count: Integer,
-                    medias:
+                    all:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All,
+                    can_create_vault_lists: T::Boolean,
+                    has_more: T::Boolean,
+                    list:
                       T::Array[
-                        Onlyfans::Models::Media::Vault::ListListResponse::Data::All::Media
+                        Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::List
                       ],
-                    photos_count: Integer,
-                    videos_count: Integer
+                    order: String,
+                    sort: String
                   }
                 )
               end
               def to_hash
               end
 
-              class Media < Onlyfans::Internal::Type::BaseModel
+              class All < Onlyfans::Internal::Type::BaseModel
                 OrHash =
                   T.type_alias do
                     T.any(
-                      Onlyfans::Models::Media::Vault::ListListResponse::Data::All::Media,
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All,
                       Onlyfans::Internal::AnyHash
                     )
                   end
 
-                sig { returns(T.nilable(String)) }
-                attr_reader :type
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :audios_count
 
-                sig { params(type: String).void }
-                attr_writer :type
+                sig { params(audios_count: Integer).void }
+                attr_writer :audios_count
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :gifs_count
+
+                sig { params(gifs_count: Integer).void }
+                attr_writer :gifs_count
+
+                sig do
+                  returns(
+                    T.nilable(
+                      T::Array[
+                        Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::Media
+                      ]
+                    )
+                  )
+                end
+                attr_reader :medias
+
+                sig do
+                  params(
+                    medias:
+                      T::Array[
+                        Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::Media::OrHash
+                      ]
+                  ).void
+                end
+                attr_writer :medias
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :photos_count
+
+                sig { params(photos_count: Integer).void }
+                attr_writer :photos_count
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :videos_count
+
+                sig { params(videos_count: Integer).void }
+                attr_writer :videos_count
+
+                sig do
+                  params(
+                    audios_count: Integer,
+                    gifs_count: Integer,
+                    medias:
+                      T::Array[
+                        Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::Media::OrHash
+                      ],
+                    photos_count: Integer,
+                    videos_count: Integer
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  audios_count: nil,
+                  gifs_count: nil,
+                  medias: nil,
+                  photos_count: nil,
+                  videos_count: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      audios_count: Integer,
+                      gifs_count: Integer,
+                      medias:
+                        T::Array[
+                          Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::Media
+                        ],
+                      photos_count: Integer,
+                      videos_count: Integer
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                class Media < Onlyfans::Internal::Type::BaseModel
+                  OrHash =
+                    T.type_alias do
+                      T.any(
+                        Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::All::Media,
+                        Onlyfans::Internal::AnyHash
+                      )
+                    end
+
+                  sig { returns(T.nilable(String)) }
+                  attr_reader :type
+
+                  sig { params(type: String).void }
+                  attr_writer :type
+
+                  sig { returns(T.nilable(String)) }
+                  attr_reader :url
+
+                  sig { params(url: String).void }
+                  attr_writer :url
+
+                  sig do
+                    params(type: String, url: String).returns(T.attached_class)
+                  end
+                  def self.new(type: nil, url: nil)
+                  end
+
+                  sig { override.returns({ type: String, url: String }) }
+                  def to_hash
+                  end
+                end
+              end
+
+              class List < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember0::Data::List,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :id
+
+                sig { params(id: Integer).void }
+                attr_writer :id
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :audios_count
+
+                sig { params(audios_count: Integer).void }
+                attr_writer :audios_count
+
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :can_delete
+
+                sig { params(can_delete: T::Boolean).void }
+                attr_writer :can_delete
+
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :can_update
+
+                sig { params(can_update: T::Boolean).void }
+                attr_writer :can_update
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :gifs_count
+
+                sig { params(gifs_count: Integer).void }
+                attr_writer :gifs_count
+
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :has_media
+
+                sig { params(has_media: T::Boolean).void }
+                attr_writer :has_media
+
+                sig { returns(T.nilable(T::Array[T.anything])) }
+                attr_reader :medias
+
+                sig { params(medias: T::Array[T.anything]).void }
+                attr_writer :medias
+
+                sig { returns(T.nilable(String)) }
+                attr_reader :name
+
+                sig { params(name: String).void }
+                attr_writer :name
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :photos_count
+
+                sig { params(photos_count: Integer).void }
+                attr_writer :photos_count
 
                 sig { returns(T.nilable(String)) }
-                attr_reader :url
+                attr_reader :type
+
+                sig { params(type: String).void }
+                attr_writer :type
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :videos_count
 
-                sig { params(url: String).void }
-                attr_writer :url
+                sig { params(videos_count: Integer).void }
+                attr_writer :videos_count
 
                 sig do
-                  params(type: String, url: String).returns(T.attached_class)
+                  params(
+                    id: Integer,
+                    audios_count: Integer,
+                    can_delete: T::Boolean,
+                    can_update: T::Boolean,
+                    gifs_count: Integer,
+                    has_media: T::Boolean,
+                    medias: T::Array[T.anything],
+                    name: String,
+                    photos_count: Integer,
+                    type: String,
+                    videos_count: Integer
+                  ).returns(T.attached_class)
                 end
-                def self.new(type: nil, url: nil)
+                def self.new(
+                  id: nil,
+                  audios_count: nil,
+                  can_delete: nil,
+                  can_update: nil,
+                  gifs_count: nil,
+                  has_media: nil,
+                  medias: nil,
+                  name: nil,
+                  photos_count: nil,
+                  type: nil,
+                  videos_count: nil
+                )
                 end
 
-                sig { override.returns({ type: String, url: String }) }
+                sig do
+                  override.returns(
+                    {
+                      id: Integer,
+                      audios_count: Integer,
+                      can_delete: T::Boolean,
+                      can_update: T::Boolean,
+                      gifs_count: Integer,
+                      has_media: T::Boolean,
+                      medias: T::Array[T.anything],
+                      name: String,
+                      photos_count: Integer,
+                      type: String,
+                      videos_count: Integer
+                    }
+                  )
+                end
                 def to_hash
                 end
               end
             end
+          end
+
+          class UnionMember1 < Onlyfans::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1,
+                  Onlyfans::Internal::AnyHash
+                )
+              end
+
+            sig do
+              returns(
+                T.nilable(
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta
+                )
+              )
+            end
+            attr_reader :_meta
 
-            class List < Onlyfans::Internal::Type::BaseModel
+            sig do
+              params(
+                _meta:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::OrHash
+              ).void
+            end
+            attr_writer :_meta
+
+            sig do
+              returns(
+                T.nilable(
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data
+                )
+              )
+            end
+            attr_reader :data
+
+            sig do
+              params(
+                data:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::OrHash
+              ).void
+            end
+            attr_writer :data
+
+            # Success (lightweight=true)
+            sig do
+              params(
+                _meta:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::OrHash,
+                data:
+                  Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::OrHash
+              ).returns(T.attached_class)
+            end
+            def self.new(_meta: nil, data: nil)
+            end
+
+            sig do
+              override.returns(
+                {
+                  _meta:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta,
+                  data:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Meta < Onlyfans::Internal::Type::BaseModel
               OrHash =
                 T.type_alias do
                   T.any(
-                    Onlyfans::Models::Media::Vault::ListListResponse::Data::List,
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta,
                     Onlyfans::Internal::AnyHash
                   )
                 end
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :id
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Cache
+                  )
+                )
+              end
+              attr_reader :_cache
 
-              sig { params(id: Integer).void }
-              attr_writer :id
+              sig do
+                params(
+                  _cache:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Cache::OrHash
+                ).void
+              end
+              attr_writer :_cache
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :audios_count
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Credits
+                  )
+                )
+              end
+              attr_reader :_credits
 
-              sig { params(audios_count: Integer).void }
-              attr_writer :audios_count
+              sig do
+                params(
+                  _credits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Credits::OrHash
+                ).void
+              end
+              attr_writer :_credits
 
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_reader :can_delete
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::RateLimits
+                  )
+                )
+              end
+              attr_reader :_rate_limits
 
-              sig { params(can_delete: T::Boolean).void }
-              attr_writer :can_delete
+              sig do
+                params(
+                  _rate_limits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::RateLimits::OrHash
+                ).void
+              end
+              attr_writer :_rate_limits
 
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_reader :can_update
+              sig do
+                params(
+                  _cache:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Cache::OrHash,
+                  _credits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Credits::OrHash,
+                  _rate_limits:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::RateLimits::OrHash
+                ).returns(T.attached_class)
+              end
+              def self.new(_cache: nil, _credits: nil, _rate_limits: nil)
+              end
 
-              sig { params(can_update: T::Boolean).void }
-              attr_writer :can_update
+              sig do
+                override.returns(
+                  {
+                    _cache:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Cache,
+                    _credits:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Credits,
+                    _rate_limits:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::RateLimits
+                  }
+                )
+              end
+              def to_hash
+              end
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :gifs_count
+              class Cache < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Cache,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
 
-              sig { params(gifs_count: Integer).void }
-              attr_writer :gifs_count
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :is_cached
 
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_reader :has_media
+                sig { params(is_cached: T::Boolean).void }
+                attr_writer :is_cached
 
-              sig { params(has_media: T::Boolean).void }
-              attr_writer :has_media
+                sig { returns(T.nilable(String)) }
+                attr_reader :note
 
-              sig { returns(T.nilable(T::Array[T.anything])) }
-              attr_reader :medias
+                sig { params(note: String).void }
+                attr_writer :note
 
-              sig { params(medias: T::Array[T.anything]).void }
-              attr_writer :medias
+                sig do
+                  params(is_cached: T::Boolean, note: String).returns(
+                    T.attached_class
+                  )
+                end
+                def self.new(is_cached: nil, note: nil)
+                end
 
-              sig { returns(T.nilable(String)) }
-              attr_reader :name
+                sig do
+                  override.returns({ is_cached: T::Boolean, note: String })
+                end
+                def to_hash
+                end
+              end
+
+              class Credits < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::Credits,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :balance
+
+                sig { params(balance: Integer).void }
+                attr_writer :balance
+
+                sig { returns(T.nilable(String)) }
+                attr_reader :note
+
+                sig { params(note: String).void }
+                attr_writer :note
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :used
+
+                sig { params(used: Integer).void }
+                attr_writer :used
+
+                sig do
+                  params(balance: Integer, note: String, used: Integer).returns(
+                    T.attached_class
+                  )
+                end
+                def self.new(balance: nil, note: nil, used: nil)
+                end
+
+                sig do
+                  override.returns(
+                    { balance: Integer, note: String, used: Integer }
+                  )
+                end
+                def to_hash
+                end
+              end
+
+              class RateLimits < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Meta::RateLimits,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :limit_day
 
-              sig { params(name: String).void }
-              attr_writer :name
+                sig { params(limit_day: Integer).void }
+                attr_writer :limit_day
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :photos_count
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :limit_minute
 
-              sig { params(photos_count: Integer).void }
-              attr_writer :photos_count
+                sig { params(limit_minute: Integer).void }
+                attr_writer :limit_minute
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :remaining_day
+
+                sig { params(remaining_day: Integer).void }
+                attr_writer :remaining_day
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :remaining_minute
+
+                sig { params(remaining_minute: Integer).void }
+                attr_writer :remaining_minute
+
+                sig do
+                  params(
+                    limit_day: Integer,
+                    limit_minute: Integer,
+                    remaining_day: Integer,
+                    remaining_minute: Integer
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  limit_day: nil,
+                  limit_minute: nil,
+                  remaining_day: nil,
+                  remaining_minute: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      limit_day: Integer,
+                      limit_minute: Integer,
+                      remaining_day: Integer,
+                      remaining_minute: Integer
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
+            end
+
+            class Data < Onlyfans::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data,
+                    Onlyfans::Internal::AnyHash
+                  )
+                end
+
+              sig do
+                returns(
+                  T.nilable(
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::All
+                  )
+                )
+              end
+              attr_reader :all
+
+              sig do
+                params(
+                  all:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::All::OrHash
+                ).void
+              end
+              attr_writer :all
+
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_reader :can_create_vault_lists
+
+              sig { params(can_create_vault_lists: T::Boolean).void }
+              attr_writer :can_create_vault_lists
+
+              sig { returns(T.nilable(T::Boolean)) }
+              attr_reader :has_more
+
+              sig { params(has_more: T::Boolean).void }
+              attr_writer :has_more
+
+              sig do
+                returns(
+                  T.nilable(
+                    T::Array[
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::List
+                    ]
+                  )
+                )
+              end
+              attr_reader :list
+
+              sig do
+                params(
+                  list:
+                    T::Array[
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::List::OrHash
+                    ]
+                ).void
+              end
+              attr_writer :list
 
               sig { returns(T.nilable(String)) }
-              attr_reader :type
+              attr_reader :order
 
-              sig { params(type: String).void }
-              attr_writer :type
+              sig { params(order: String).void }
+              attr_writer :order
 
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :videos_count
+              sig { returns(T.nilable(String)) }
+              attr_reader :sort
 
-              sig { params(videos_count: Integer).void }
-              attr_writer :videos_count
+              sig { params(sort: String).void }
+              attr_writer :sort
 
               sig do
                 params(
-                  id: Integer,
-                  audios_count: Integer,
-                  can_delete: T::Boolean,
-                  can_update: T::Boolean,
-                  gifs_count: Integer,
-                  has_media: T::Boolean,
-                  medias: T::Array[T.anything],
-                  name: String,
-                  photos_count: Integer,
-                  type: String,
-                  videos_count: Integer
+                  all:
+                    Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::All::OrHash,
+                  can_create_vault_lists: T::Boolean,
+                  has_more: T::Boolean,
+                  list:
+                    T::Array[
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::List::OrHash
+                    ],
+                  order: String,
+                  sort: String
                 ).returns(T.attached_class)
               end
               def self.new(
-                id: nil,
-                audios_count: nil,
-                can_delete: nil,
-                can_update: nil,
-                gifs_count: nil,
-                has_media: nil,
-                medias: nil,
-                name: nil,
-                photos_count: nil,
-                type: nil,
-                videos_count: nil
+                all: nil,
+                can_create_vault_lists: nil,
+                has_more: nil,
+                list: nil,
+                order: nil,
+                sort: nil
               )
               end
 
               sig do
                 override.returns(
                   {
-                    id: Integer,
-                    audios_count: Integer,
-                    can_delete: T::Boolean,
-                    can_update: T::Boolean,
-                    gifs_count: Integer,
-                    has_media: T::Boolean,
-                    medias: T::Array[T.anything],
-                    name: String,
-                    photos_count: Integer,
-                    type: String,
-                    videos_count: Integer
+                    all:
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::All,
+                    can_create_vault_lists: T::Boolean,
+                    has_more: T::Boolean,
+                    list:
+                      T::Array[
+                        Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::List
+                      ],
+                    order: String,
+                    sort: String
                   }
                 )
               end
               def to_hash
               end
+
+              class All < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::All,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :media_count
+
+                sig { params(media_count: Integer).void }
+                attr_writer :media_count
+
+                sig { params(media_count: Integer).returns(T.attached_class) }
+                def self.new(media_count: nil)
+                end
+
+                sig { override.returns({ media_count: Integer }) }
+                def to_hash
+                end
+              end
+
+              class List < Onlyfans::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Onlyfans::Models::Media::Vault::ListListResponse::UnionMember1::Data::List,
+                      Onlyfans::Internal::AnyHash
+                    )
+                  end
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :id
+
+                sig { params(id: Integer).void }
+                attr_writer :id
+
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :can_update
+
+                sig { params(can_update: T::Boolean).void }
+                attr_writer :can_update
+
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :media_count
+
+                sig { params(media_count: Integer).void }
+                attr_writer :media_count
+
+                sig { returns(T.nilable(String)) }
+                attr_reader :name
+
+                sig { params(name: String).void }
+                attr_writer :name
+
+                sig { returns(T.nilable(String)) }
+                attr_reader :type
+
+                sig { params(type: String).void }
+                attr_writer :type
+
+                sig do
+                  params(
+                    id: Integer,
+                    can_update: T::Boolean,
+                    media_count: Integer,
+                    name: String,
+                    type: String
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  id: nil,
+                  can_update: nil,
+                  media_count: nil,
+                  name: nil,
+                  type: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      id: Integer,
+                      can_update: T::Boolean,
+                      media_count: Integer,
+                      name: String,
+                      type: String
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
             end
           end
+
+          sig do
+            override.returns(
+              T::Array[
+                Onlyfans::Models::Media::Vault::ListListResponse::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
         end
       end
     end