fastpixapi 1.1.3 → 1.2.0

data/lib/fastpix_client/models/components/update_media.rbi

@@ -36,8 +36,10 @@ class FastpixClient::Models::Components::UpdateMedia
   def moderation=(str_); end
   def subtitle_available(); end
   def subtitle_available=(str_); end
+  def optimize_audio(); end
+  def optimize_audio=(str_); end
   def duration(); end
-  def duration=(str_); end
+  def duration=(float_); end
   def aspect_ratio(); end
   def aspect_ratio=(str_); end
   def created_at(); end

data/lib/fastpix_client/models/components/update_media_maxresolution.rb

@@ -17,7 +17,6 @@ module FastpixClient
           ONE_THOUSAND_AND_EIGHTYP = new('1080p')
           SEVEN_HUNDRED_AND_TWENTYP = new('720p')
           FOUR_HUNDRED_AND_EIGHTYP = new('480p')
-          THREE_HUNDRED_AND_SIXTYP = new('360p')
         end
       end
     end

data/lib/fastpix_client/models/components/update_media_mp4support.rb

@@ -7,20 +7,40 @@
 module FastpixClient
   module Models
     module Components
-      # UpdateMediaMp4Support - Determines the type of MP4 support for the media.
-      # - **none**: Disables MP4 support.
-      # - **capped_4k**: Enables MP4 downloads with resolutions up to 4K.
-      # - **audioOnly**: Provides an MP4 stream containing only the audio.
-      # - **audioOnly,capped_4k**: Enables both MP4 video downloads (up to 4K) and an audio-only stream.
-      # 
-      class UpdateMediaMp4Support < T::Enum
+      # UpdateMediaMp4Support - One MP4 rendition generated for the media when MP4 support is requested.
+      class UpdateMediaMp4Support
+        extend T::Sig
+        include Crystalline::MetadataFields
 
+        # The MP4 rendition type. `capped_4k` is a downloadable MP4 video capped at 4K resolution, `audioOnly` is a downloadable m4a audio-only file.
+        field :type, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('type') } }
+        # Generation status of this MP4 rendition. One of `preparing`, `ready`, or `failed`.
+        field :status, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('status') } }
+        # Pixel height of the rendition. Omitted for the `audioOnly` type.
+        field :height, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('height') } }
+        # Pixel width of the rendition. Omitted for the `audioOnly` type.
+        field :width, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('width') } }
+        # File extension of the downloadable rendition. One of `mp4` or `m4a`.
+        field :ext, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('ext') } }
 
-        enums do
-          NONE = new('none')
-          CAPPED_4K = new('capped_4k')
-          AUDIO_ONLY = new('audioOnly')
-          AUDIO_ONLY_CAPPED_4K = new('audioOnly,capped_4k')
+        sig { params(type: T.nilable(::String), status: T.nilable(::String), height: T.nilable(::Integer), width: T.nilable(::Integer), ext: T.nilable(::String)).void }
+        def initialize(type: nil, status: nil, height: nil, width: nil, ext: nil)
+          @type = type
+          @status = status
+          @height = height
+          @width = width
+          @ext = ext
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @type == other.type
+          return false unless @status == other.status
+          return false unless @height == other.height
+          return false unless @width == other.width
+          return false unless @ext == other.ext
+          true
         end
       end
     end

data/lib/fastpix_client/models/components/update_media_mp4support.rbi

@@ -8,4 +8,14 @@ end
 
 
 class FastpixClient::Models::Components::UpdateMediaMp4Support
-end
+  def type(); end
+  def type=(str_); end
+  def status(); end
+  def status=(str_); end
+  def height(); end
+  def height=(str_); end
+  def width(); end
+  def width=(str_); end
+  def ext(); end
+  def ext=(str_); end
+end

data/lib/fastpix_client/models/components/updatetrackrequest.rb

@@ -7,31 +7,31 @@
 module FastpixClient
   module Models
     module Components
-      # Contains details about the track being added to the media file.
+      # Contains details about the track being updated. The track's file (`url`) cannot be changed — only its language and title.
       class UpdateTrackRequest
         extend T::Sig
         include Crystalline::MetadataFields
 
-        # The direct URL of the track file. It must point to a valid audio or subtitle file.
-        field :url, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('url') } }
         # The BCP 47 language code representing the track’s language.
         field :language_code, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('languageCode') } }
         # The full name of the language corresponding to the `languageCode`.
         field :language_name, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('languageName') } }
+        # Title of the track.
+        field :title, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('title') } }
 
-        sig { params(url: T.nilable(::String), language_code: T.nilable(::String), language_name: T.nilable(::String)).void }
-        def initialize(url: 'http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/thrust.vtt', language_code: 'fr', language_name: 'French')
-          @url = url
+        sig { params(language_code: T.nilable(::String), language_name: T.nilable(::String), title: T.nilable(::String)).void }
+        def initialize(language_code: 'fr', language_name: 'French', title: nil)
           @language_code = language_code
           @language_name = language_name
+          @title = title
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
-          return false unless @url == other.url
           return false unless @language_code == other.language_code
           return false unless @language_name == other.language_name
+          return false unless @title == other.title
           true
         end
       end

data/lib/fastpix_client/models/components/updatetrackrequest.rbi

@@ -8,10 +8,10 @@ end
 
 
 class FastpixClient::Models::Components::UpdateTrackRequest
-  def url(); end
-  def url=(str_); end
   def language_code(); end
   def language_code=(str_); end
   def language_name(); end
   def language_name=(str_); end
+  def title(); end
+  def title=(str_); end
 end

data/lib/fastpix_client/models/components/updatetrackresponse.rb

@@ -22,14 +22,17 @@ module FastpixClient
         field :language_code, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('languageCode') } }
         # The full name of the language corresponding to the `languageCode`.
         field :language_name, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('languageName') } }
+        # Title of the track.
+        field :title, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('title') } }
 
-        sig { params(id: T.nilable(::String), type: T.nilable(Models::Components::UpdateTrackResponseType), url: T.nilable(::String), language_code: T.nilable(::String), language_name: T.nilable(::String)).void }
-        def initialize(id: nil, type: nil, url: nil, language_code: nil, language_name: nil)
+        sig { params(id: T.nilable(::String), type: T.nilable(Models::Components::UpdateTrackResponseType), url: T.nilable(::String), language_code: T.nilable(::String), language_name: T.nilable(::String), title: T.nilable(::String)).void }
+        def initialize(id: nil, type: nil, url: nil, language_code: nil, language_name: nil, title: nil)
           @id = id
           @type = type
           @url = url
           @language_code = language_code
           @language_name = language_name
+          @title = title
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
@@ -40,6 +43,7 @@ module FastpixClient
           return false unless @url == other.url
           return false unless @language_code == other.language_code
           return false unless @language_name == other.language_name
+          return false unless @title == other.title
           true
         end
       end

data/lib/fastpix_client/models/components/updatetrackresponse.rbi

@@ -18,4 +18,6 @@ class FastpixClient::Models::Components::UpdateTrackResponse
   def language_code=(str_); end
   def language_name(); end
   def language_name=(str_); end
+  def title(); end
+  def title=(str_); end
 end

data/lib/fastpix_client/models/components/videotrack.rb

@@ -24,15 +24,18 @@ module FastpixClient
         field :frame_rate, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('frameRate') } }
         # Indicates the current state of the track. 'available' means the track has been processed successfully and is ready to be used or played.
         field :status, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('status') } }
+        # Title of the track.
+        field :title, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('title') } }
 
-        sig { params(id: T.nilable(::String), type: T.nilable(::String), width: T.nilable(::Float), height: T.nilable(::Float), frame_rate: T.nilable(::String), status: T.nilable(::String)).void }
-        def initialize(id: nil, type: nil, width: nil, height: nil, frame_rate: nil, status: nil)
+        sig { params(id: T.nilable(::String), type: T.nilable(::String), width: T.nilable(::Float), height: T.nilable(::Float), frame_rate: T.nilable(::String), status: T.nilable(::String), title: T.nilable(::String)).void }
+        def initialize(id: nil, type: nil, width: nil, height: nil, frame_rate: nil, status: nil, title: nil)
           @id = id
           @type = type
           @width = width
           @height = height
           @frame_rate = frame_rate
           @status = status
+          @title = title
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
@@ -44,6 +47,7 @@ module FastpixClient
           return false unless @height == other.height
           return false unless @frame_rate == other.frame_rate
           return false unless @status == other.status
+          return false unless @title == other.title
           true
         end
       end

data/lib/fastpix_client/models/components/videotrack.rbi

@@ -20,4 +20,6 @@ class FastpixClient::Models::Components::VideoTrack
   def frame_rate=(str_); end
   def status(); end
   def status=(str_); end
+  def title(); end
+  def title=(str_); end
 end

data/lib/fastpix_client/models/components/videotrackforgetall.rb

@@ -22,14 +22,17 @@ module FastpixClient
         field :height, Crystalline::Nilable.new(::Float), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('height') } }
         # Indicates the current state of the track. 'available' means the track has been processed successfully and is ready to be used or played.
         field :status, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('status') } }
+        # Title of the track.
+        field :title, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('title') } }
 
-        sig { params(id: T.nilable(::String), type: T.nilable(::String), width: T.nilable(::Float), height: T.nilable(::Float), status: T.nilable(::String)).void }
-        def initialize(id: nil, type: nil, width: nil, height: nil, status: nil)
+        sig { params(id: T.nilable(::String), type: T.nilable(::String), width: T.nilable(::Float), height: T.nilable(::Float), status: T.nilable(::String), title: T.nilable(::String)).void }
+        def initialize(id: nil, type: nil, width: nil, height: nil, status: nil, title: nil)
           @id = id
           @type = type
           @width = width
           @height = height
           @status = status
+          @title = title
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
@@ -40,6 +43,7 @@ module FastpixClient
           return false unless @width == other.width
           return false unless @height == other.height
           return false unless @status == other.status
+          return false unless @title == other.title
           true
         end
       end

data/lib/fastpix_client/models/components/videotrackforgetall.rbi

@@ -18,4 +18,6 @@ class FastpixClient::Models::Components::VideoTrackForGetAll
   def height=(str_); end
   def status(); end
   def status=(str_); end
+  def title(); end
+  def title=(str_); end
 end

data/lib/fastpix_client/models/components.rb

@@ -77,13 +77,13 @@ module FastpixClient
       autoload :GetAllPlaylistsResponse, 'fastpix_client/models/components/getallplaylistsresponse.rb'
       autoload :GetAllSigningKeysResponse, 'fastpix_client/models/components/getallsigningkeysresponse.rb'
       autoload :GetAllSigningKeysResponseDto, 'fastpix_client/models/components/getallsigningkeysresponsedto.rb'
-      autoload :GetMediaResponse, 'fastpix_client/models/components/getmediaresponse.rb'
-      autoload :GetMediaResponseMaxResolution, 'fastpix_client/models/components/getmediaresponse_maxresolution.rb'
-      autoload :GetMediaResponseMediaQuality, 'fastpix_client/models/components/getmediaresponse_mediaquality.rb'
-      autoload :GetMediaResponseMp4Support, 'fastpix_client/models/components/getmediaresponse_mp4support.rb'
-      autoload :GetMediaResponseSourceResolution, 'fastpix_client/models/components/getmediaresponse_sourceresolution.rb'
-      autoload :GetMediaResponseStatus, 'fastpix_client/models/components/getmediaresponse_status.rb'
-      autoload :GetMediaResponseTrack, 'fastpix_client/models/components/getmediaresponse_track.rb'
+      autoload :GetMediaDetailResponse, 'fastpix_client/models/components/getmediadetailresponse.rb'
+      autoload :GetMediaDetailResponseMaxResolution, 'fastpix_client/models/components/getmediadetailresponse_maxresolution.rb'
+      autoload :GetMediaDetailResponseMediaQuality, 'fastpix_client/models/components/getmediadetailresponse_mediaquality.rb'
+      autoload :GetMediaDetailResponseMp4Support, 'fastpix_client/models/components/getmediadetailresponse_mp4support.rb'
+      autoload :GetMediaDetailResponseSourceResolution, 'fastpix_client/models/components/getmediadetailresponse_sourceresolution.rb'
+      autoload :GetMediaDetailResponseStatus, 'fastpix_client/models/components/getmediadetailresponse_status.rb'
+      autoload :GetMediaDetailResponseTrack, 'fastpix_client/models/components/getmediadetailresponse_track.rb'
       autoload :LanguageCode, 'fastpix_client/models/components/languagecode.rb'
       autoload :LiveMediaClips, 'fastpix_client/models/components/live_media_clips.rb'
       autoload :LiveMediaClipsMaxResolution, 'fastpix_client/models/components/live_media_clips_maxresolution.rb'

data/lib/fastpix_client/models/operations/get_media_response.rb

@@ -20,7 +20,7 @@ module FastpixClient
         field :raw_response, ::Faraday::Response
         # Get a video media by id
         field :object, Crystalline::Nilable.new(Models::Operations::GetMediaResponseBody)
-        # See the range of possible <a href="https://fastpix.com/docs/error-codes">error</a> responses and their status codes.
+        # See the range of possible <a href="https://fastpix.com/docs/error-codes/error-codes">error</a> responses and their status codes.
         field :default_error, Crystalline::Nilable.new(Models::Components::DefaultError)
 
         sig { params(content_type: ::String, status_code: ::Integer, raw_response: ::Faraday::Response, object: T.nilable(Models::Operations::GetMediaResponseBody), default_error: T.nilable(Models::Components::DefaultError)).void }

data/lib/fastpix_client/models/operations/get_media_responsebody.rb

@@ -15,9 +15,9 @@ module FastpixClient
         # Demonstrates whether the request is successful or not.
         field :success, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('success') } }
 
-        field :data, Crystalline::Nilable.new(Models::Components::GetMediaResponse), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('data') } }
+        field :data, Crystalline::Nilable.new(Models::Components::GetMediaDetailResponse), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('data') } }
 
-        sig { params(success: T.nilable(T::Boolean), data: T.nilable(Models::Components::GetMediaResponse)).void }
+        sig { params(success: T.nilable(T::Boolean), data: T.nilable(Models::Components::GetMediaDetailResponse)).void }
         def initialize(success: nil, data: nil)
           @success = success
           @data = data

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_data.rb

@@ -0,0 +1,40 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Operations
+
+      class UpdateLiveStreamDomainRestrictionsData
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Specify the fallback behavior for domains that are not listed in the allow or deny lists.
+        field :default_policy, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('defaultPolicy') } }
+        # List of domains explicitly allowed to play the media.
+        field :allow, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('allow') } }
+        # List of domains explicitly denied from accessing the media.
+        field :deny, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('deny') } }
+
+        sig { params(default_policy: T.nilable(::String), allow: T.nilable(T::Array[::String]), deny: T.nilable(T::Array[::String])).void }
+        def initialize(default_policy: nil, allow: nil, deny: nil)
+          @default_policy = default_policy
+          @allow = allow
+          @deny = deny
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @default_policy == other.default_policy
+          return false unless @allow == other.allow
+          return false unless @deny == other.deny
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_data.rbi

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsData
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsData
+  def default_policy(); end
+  def default_policy=(str_); end
+  def allow(); end
+  def allow=(str_); end
+  def deny(); end
+  def deny=(str_); end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_defaultpolicy.rb

@@ -0,0 +1,21 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Operations
+      # UpdateLiveStreamDomainRestrictionsDefaultPolicy - Specify the fallback behavior for domains that are not listed in the `allow` or `deny` lists.
+      class UpdateLiveStreamDomainRestrictionsDefaultPolicy < T::Enum
+
+
+        enums do
+          ALLOW = new('allow')
+          DENY = new('deny')
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_defaultpolicy.rbi

@@ -0,0 +1,11 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsDefaultPolicy
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsDefaultPolicy
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_request.rb

@@ -0,0 +1,40 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Operations
+
+      class UpdateLiveStreamDomainRestrictionsRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+
+        field :stream_id, ::String, { 'path_param': { 'field_name': 'streamId', 'style': 'simple', 'explode': false } }
+
+        field :playback_id, ::String, { 'path_param': { 'field_name': 'playbackId', 'style': 'simple', 'explode': false } }
+
+        field :body, Models::Operations::UpdateLiveStreamDomainRestrictionsRequestBody, { 'request': { 'media_type': 'application/json' } }
+
+        sig { params(stream_id: ::String, playback_id: ::String, body: Models::Operations::UpdateLiveStreamDomainRestrictionsRequestBody).void }
+        def initialize(stream_id:, playback_id:, body:)
+          @stream_id = stream_id
+          @playback_id = playback_id
+          @body = body
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @stream_id == other.stream_id
+          return false unless @playback_id == other.playback_id
+          return false unless @body == other.body
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_request.rbi

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsRequest
+  def stream_id(); end
+  def stream_id=(str_); end
+  def playback_id(); end
+  def playback_id=(str_); end
+  def body(); end
+  def body=(str_); end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_requestbody.rb

@@ -0,0 +1,40 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Operations
+
+      class UpdateLiveStreamDomainRestrictionsRequestBody
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # List of domains explicitly allowed to play the media.
+        field :allow, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('allow') } }
+        # List of domains explicitly denied from accessing the media.
+        field :deny, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('deny') } }
+        # Specify the fallback behavior for domains that are not listed in the `allow` or `deny` lists.
+        field :default_policy, Crystalline::Nilable.new(Models::Operations::UpdateLiveStreamDomainRestrictionsDefaultPolicy), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('defaultPolicy'), 'decoder': Utils.enum_from_string(Models::Operations::UpdateLiveStreamDomainRestrictionsDefaultPolicy, true) } }
+
+        sig { params(allow: T.nilable(T::Array[::String]), deny: T.nilable(T::Array[::String]), default_policy: T.nilable(Models::Operations::UpdateLiveStreamDomainRestrictionsDefaultPolicy)).void }
+        def initialize(allow: nil, deny: nil, default_policy: Models::Operations::UpdateLiveStreamDomainRestrictionsDefaultPolicy::ALLOW)
+          @allow = allow
+          @deny = deny
+          @default_policy = default_policy
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @allow == other.allow
+          return false unless @deny == other.deny
+          return false unless @default_policy == other.default_policy
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_requestbody.rbi

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsRequestBody
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsRequestBody
+  def allow(); end
+  def allow=(str_); end
+  def deny(); end
+  def deny=(str_); end
+  def default_policy(); end
+  def default_policy=(str_); end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_response.rb

@@ -0,0 +1,48 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Operations
+
+      class UpdateLiveStreamDomainRestrictionsResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # HTTP response content type for this operation
+        field :content_type, ::String
+        # HTTP response status code for this operation
+        field :status_code, ::Integer
+        # Raw HTTP response; suitable for custom response parsing
+        field :raw_response, ::Faraday::Response
+        # Successfully updated domain restrictions
+        field :object, Crystalline::Nilable.new(Models::Operations::UpdateLiveStreamDomainRestrictionsResponseBody)
+        # See the range of possible <a href="https://fastpix.com/docs/error-codes">error</a> responses and their status codes.
+        field :default_error, Crystalline::Nilable.new(Models::Components::DefaultError)
+
+        sig { params(content_type: ::String, status_code: ::Integer, raw_response: ::Faraday::Response, object: T.nilable(Models::Operations::UpdateLiveStreamDomainRestrictionsResponseBody), default_error: T.nilable(Models::Components::DefaultError)).void }
+        def initialize(content_type:, status_code:, raw_response:, object: nil, default_error: nil)
+          @content_type = content_type
+          @status_code = status_code
+          @raw_response = raw_response
+          @object = object
+          @default_error = default_error
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @content_type == other.content_type
+          return false unless @status_code == other.status_code
+          return false unless @raw_response == other.raw_response
+          return false unless @object == other.object
+          return false unless @default_error == other.default_error
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def object(); end
+  def object=(str_); end
+  def default_error(); end
+  def default_error=(str_); end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_responsebody.rb

@@ -0,0 +1,36 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Operations
+      # Successfully updated domain restrictions
+      class UpdateLiveStreamDomainRestrictionsResponseBody
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Shows the request status. Returns true for success and false for failure.
+        field :success, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('success') } }
+
+        field :data, Crystalline::Nilable.new(Models::Operations::UpdateLiveStreamDomainRestrictionsData), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('data') } }
+
+        sig { params(success: T.nilable(T::Boolean), data: T.nilable(Models::Operations::UpdateLiveStreamDomainRestrictionsData)).void }
+        def initialize(success: nil, data: nil)
+          @success = success
+          @data = data
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @success == other.success
+          return false unless @data == other.data
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/models/operations/update_live_stream_domain_restrictions_responsebody.rbi

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsResponseBody
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Operations::UpdateLiveStreamDomainRestrictionsResponseBody
+  def success(); end
+  def success=(str_); end
+  def data(); end
+  def data=(str_); end
+end