fastpixapi 1.1.4 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd2162d339bc78c7eca4ab3e7c4aa40556a82c8d2181c290fa37f2febf6a2d8a
-  data.tar.gz: 22b7ebf19e385d5d635b647f78ec3090e3612b6f047648194e094224b0baee96
+  metadata.gz: 61193159cda175fba2c8a1a939a4aabdf5ffdb6b0077fe7c60a0d96051001cae
+  data.tar.gz: a8b192da1ff5a627de29295d5c1c85a5816bf85f7f5917f80f966a97048de6e8
 SHA512:
-  metadata.gz: 4d952510eddef77d7bf6e3266ee2507fdb88e3679574cf7f4d7c954819a3e9538569c31285718493e7a935d2f114157f62c0798fe0722d64e922a04be0cd86d3
-  data.tar.gz: a73898288cb56887aa9a95d3082b45712da8836c769c937869c77960f846f1409f66bc3f658a8b5efe8298d84167a4d2d0777cb9f717739a34e6cc77a2051446
+  metadata.gz: 25571c8ad27dca1459644bf7b770aa39ea157fcd910f76136138d059f9533c71b6cf75c8e80e48bdf8cc3e33891b3644787b4aa66b4fd642736ab38096e44e6f
+  data.tar.gz: 844af40feb387941740b6a8772c7a721580049d6ffa9599bc6463ee3c54682d04716ca17d18c92cc5282226e229abab7a76c1ef589c6fd8863066ec832094d22

data/lib/crystalline/metadata_fields.rb

@@ -53,6 +53,8 @@ module Crystalline
           # rubocop:enable Lint/SuppressedException
           return value
         elsif field_type.to_s == 'Float'
+          raise TypeError, "Cannot convert #{value.inspect} to Float. The value is of type #{value.class}" unless value.is_a?(::Numeric)
+
           return value.to_f
 
         end

data/lib/crystalline/module.rb

@@ -32,19 +32,7 @@ module Crystalline
     if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
       type.from_dict(data)
     elsif Crystalline::Utils.union? type
-      union_types = Crystalline::Utils.get_union_types(type)
-      union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
-
-      union_types.each do |union_type|
-        unmarshalled_val = Crystalline.unmarshal_json(data, union_type)
-        return unmarshalled_val
-      rescue TypeError
-        next
-      rescue NoMethodError
-        next
-      rescue KeyError
-        next
-      end
+      unmarshal_union(data, type)
     elsif Crystalline::Utils.arr? type
       data.map { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.arr_of(type)) }
     elsif Crystalline::Utils.hash? type
@@ -60,6 +48,17 @@ module Crystalline
     end
   end
 
+  def self.unmarshal_union(data, type)
+    union_types = Crystalline::Utils.get_union_types(type)
+    union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
+
+    union_types.each do |union_type|
+      return Crystalline.unmarshal_json(data, union_type)
+    rescue TypeError, NoMethodError, KeyError
+      next
+    end
+  end
+
   def self.json_encode(val, primitives: true)
     if val.class.respond_to? :enums
       val.serialize

data/lib/fastpix_client/live_playback.rb

@@ -439,5 +439,258 @@ module FastpixClient
         end
       end
     end
+
+
+
+    sig { params(body: Models::Operations::UpdateLiveStreamDomainRestrictionsRequestBody, stream_id: ::String, playback_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::UpdateLiveStreamDomainRestrictionsResponse) }
+    def update_live_stream_domain_restrictions(body:, stream_id:, playback_id:, timeout_ms: nil)
+      # update_live_stream_domain_restrictions - Update domain restrictions for a live stream playback ID
+      # This endpoint updates domain-level restrictions for a specific playback ID associated with a live stream.
+      # It allows you to restrict playback to specific domains or block known unauthorized domains.
+      # 
+      # **How it works:**
+      # 1. Make a `PATCH` request to this endpoint with your desired domain access configuration.
+      # 2. Set a default policy (`allow` or `deny`) and specify domain names in the `allow` or `deny` lists.
+      # 3. This is commonly used to restrict video playback to your website or approved client domains.
+      # 
+      # **Example:**
+      # A streaming service can allow playback only from `example.com` and deny all others by setting: `"defaultPolicy": "deny"` and `"allow": ["example.com"]`.
+      # 
+      request = Models::Operations::UpdateLiveStreamDomainRestrictionsRequest.new(
+        stream_id: stream_id,
+        playback_id: playback_id,
+        body: body
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::UpdateLiveStreamDomainRestrictionsRequest,
+        base_url,
+        '/live/streams/{streamId}/playback-ids/{playbackId}/domains',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :body, :json)
+      headers['content-type'] = req_content_type
+      body = encode_request_body(req_content_type, data, form)
+      headers['Accept'] = CONTENT_TYPE_JSON
+      headers[USER_AGENT_HEADER] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'update-live-stream-domain-restrictions',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).patch(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        http_response = apply_after_request_hooks(http_response, error, hook_ctx)
+      end
+      
+      content_type = http_response.headers.fetch(CONTENT_TYPE_HEADER, DEFAULT_CONTENT_TYPE)
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, CONTENT_TYPE_JSON)
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Operations::UpdateLiveStreamDomainRestrictionsResponseBody)
+          response = Models::Operations::UpdateLiveStreamDomainRestrictionsResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            object: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), UNKNOWN_CONTENT_TYPE_ERROR
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), API_ERROR_OCCURRED
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), API_ERROR_OCCURRED
+      else
+        if Utils.match_content_type(content_type, CONTENT_TYPE_JSON)
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::DefaultError)
+          response = Models::Operations::UpdateLiveStreamDomainRestrictionsResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            default_error: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), UNKNOWN_CONTENT_TYPE_ERROR
+        end
+      end
+    end
+
+
+    sig { params(body: Models::Operations::UpdateLiveStreamUserAgentRestrictionsRequestBody, stream_id: ::String, playback_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::UpdateLiveStreamUserAgentRestrictionsResponse) }
+    def update_live_stream_user_agent_restrictions(body:, stream_id:, playback_id:, timeout_ms: nil)
+      # update_live_stream_user_agent_restrictions - Update user-agent restrictions for a live stream playback ID
+      # This endpoint allows updating user-agent restrictions for a specific playback ID associated with a live stream. 
+      # It can be used to allow or deny specific user-agents during playback request evaluation.
+      # 
+      # **How it works:**
+      # 1. Make a `PATCH` request to this endpoint with your desired user-agent access configuration.
+      # 2. Specify a default policy (`allow` or `deny`) and provide specific `allow` or `deny` lists.
+      # 3. Use this to restrict access to specific browsers, devices, or bots.
+      # 
+      # **Example:**
+      # A developer may configure a playback ID to deny access from known scraping user-agents while allowing all others by default.
+      # 
+      request = Models::Operations::UpdateLiveStreamUserAgentRestrictionsRequest.new(
+        stream_id: stream_id,
+        playback_id: playback_id,
+        body: body
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::UpdateLiveStreamUserAgentRestrictionsRequest,
+        base_url,
+        '/live/streams/{streamId}/playback-ids/{playbackId}/user-agents',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :body, :json)
+      headers['content-type'] = req_content_type
+      body = encode_request_body(req_content_type, data, form)
+      headers['Accept'] = CONTENT_TYPE_JSON
+      headers[USER_AGENT_HEADER] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'update-live-stream-user-agent-restrictions',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).patch(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        http_response = apply_after_request_hooks(http_response, error, hook_ctx)
+      end
+      
+      content_type = http_response.headers.fetch(CONTENT_TYPE_HEADER, DEFAULT_CONTENT_TYPE)
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, CONTENT_TYPE_JSON)
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Operations::UpdateLiveStreamUserAgentRestrictionsResponseBody)
+          response = Models::Operations::UpdateLiveStreamUserAgentRestrictionsResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            object: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), UNKNOWN_CONTENT_TYPE_ERROR
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), API_ERROR_OCCURRED
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), API_ERROR_OCCURRED
+      else
+        if Utils.match_content_type(content_type, CONTENT_TYPE_JSON)
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::DefaultError)
+          response = Models::Operations::UpdateLiveStreamUserAgentRestrictionsResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            default_error: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), UNKNOWN_CONTENT_TYPE_ERROR
+        end
+      end
+    end
   end
 end

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

@@ -25,7 +25,7 @@ module FastpixClient
         # 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::AddTrackResponseType), url: T.nilable(::String), language_code: T.nilable(::String), language_name: T.nilable(::String), title: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), type: T.nilable(T.any(Models::Components::AddTrackResponseType, String)), 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

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

@@ -27,7 +27,7 @@ module FastpixClient
         # 
         field :language_code, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('languageCode') } }
 
-        sig { params(id: T.nilable(::String), type: T.nilable(Models::Components::AudioTrackType), status: T.nilable(::String), title: T.nilable(::String), language_name: T.nilable(::String), language_code: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), type: T.nilable(T.any(Models::Components::AudioTrackType, String)), status: T.nilable(::String), title: T.nilable(::String), language_name: T.nilable(::String), language_code: T.nilable(::String)).void }
         def initialize(id: nil, type: nil, status: nil, title: nil, language_name: nil, language_code: nil)
           @id = id
           @type = type

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

@@ -41,7 +41,7 @@ module FastpixClient
         # 
         field :trial, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('trial') } }
 
-        sig { params(id: T.nilable(::String), status: T.nilable(Models::Components::CreateMediaResponseStatus), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), metadata: T.nilable(T::Hash[Symbol, ::String]), media_quality: T.nilable(Models::Components::CreateMediaResponseMediaQuality), source_access: T.nilable(T::Boolean), max_resolution: T.nilable(Models::Components::CreateMediaResponseMaxResolution), inputs: T.nilable(T::Array[Models::Components::CreateMediaResponseInput]), optimize_audio: T.nilable(T::Boolean), trial: T.nilable(T::Boolean)).void }
+        sig { params(id: T.nilable(::String), status: T.nilable(T.any(Models::Components::CreateMediaResponseStatus, String)), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), metadata: T.nilable(T::Hash[Symbol, ::String]), media_quality: T.nilable(T.any(Models::Components::CreateMediaResponseMediaQuality, String)), source_access: T.nilable(T::Boolean), max_resolution: T.nilable(T.any(Models::Components::CreateMediaResponseMaxResolution, String)), inputs: T.nilable(T::Array[Models::Components::CreateMediaResponseInput]), optimize_audio: T.nilable(T::Boolean), trial: T.nilable(T::Boolean)).void }
         def initialize(id: nil, status: nil, created_at: nil, updated_at: nil, playback_ids: nil, metadata: nil, media_quality: nil, source_access: nil, max_resolution: nil, inputs: nil, optimize_audio: nil, trial: true)
           @id = id
           @status = status

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

@@ -21,7 +21,7 @@ module FastpixClient
         # The maximum resolution for the playback ID.
         field :resolution, Crystalline::Nilable.new(Models::Components::Resolution), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('resolution'), 'decoder': Utils.enum_from_string(Models::Components::Resolution, true) } }
 
-        sig { params(id: T.nilable(::String), access_policy: T.nilable(Models::Components::AccessPolicy), access_restrictions: T.nilable(Models::Components::CreatePlaybackIdAccessRestrictions), resolution: T.nilable(Models::Components::Resolution)).void }
+        sig { params(id: T.nilable(::String), access_policy: T.nilable(T.any(Models::Components::AccessPolicy, String)), access_restrictions: T.nilable(Models::Components::CreatePlaybackIdAccessRestrictions), resolution: T.nilable(T.any(Models::Components::Resolution, String))).void }
         def initialize(id: nil, access_policy: nil, access_restrictions: nil, resolution: nil)
           @id = id
           @access_policy = access_policy

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

@@ -19,7 +19,7 @@ module FastpixClient
         # A list of domains that are explicitly blocked from accessing the resource.
         field :deny, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('deny') } }
 
-        sig { params(default_policy: T.nilable(Models::Components::PolicyAction), allow: T.nilable(T::Array[::String]), deny: T.nilable(T::Array[::String])).void }
+        sig { params(default_policy: T.nilable(T.any(Models::Components::PolicyAction, 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

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

@@ -19,7 +19,7 @@ module FastpixClient
         # A list of specific user agents that are blocked.
         field :deny, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('deny') } }
 
-        sig { params(default_policy: T.nilable(Models::Components::PolicyAction), allow: T.nilable(T::Array[::String]), deny: T.nilable(T::Array[::String])).void }
+        sig { params(default_policy: T.nilable(T.any(Models::Components::PolicyAction, 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

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

@@ -28,7 +28,7 @@ module FastpixClient
         # 
         field :timeout, Crystalline::Nilable.new(::Float), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('timeout') } }
 
-        sig { params(upload_id: T.nilable(::String), trial: T.nilable(T::Boolean), status: T.nilable(Models::Components::DirectUploadStatus), url: T.nilable(::String), cors_origin: T.nilable(::String), push_media_settings: T.nilable(Models::Components::DirectUploadResponse), timeout: T.nilable(::Float)).void }
+        sig { params(upload_id: T.nilable(::String), trial: T.nilable(T::Boolean), status: T.nilable(T.any(Models::Components::DirectUploadStatus, String)), url: T.nilable(::String), cors_origin: T.nilable(::String), push_media_settings: T.nilable(Models::Components::DirectUploadResponse), timeout: T.nilable(::Float)).void }
         def initialize(upload_id: nil, trial: nil, status: nil, url: nil, cors_origin: nil, push_media_settings: nil, timeout: 14_400.0)
           @upload_id = upload_id
           @trial = trial

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

@@ -26,7 +26,7 @@ module FastpixClient
         # 
         field :optimize_audio, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('optimizeAudio') } }
 
-        sig { params(playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), metadata: T.nilable(T::Hash[Symbol, ::String]), media_quality: T.nilable(Models::Components::DirectUploadResponseMediaQuality), source_access: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean)).void }
+        sig { params(playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), metadata: T.nilable(T::Hash[Symbol, ::String]), media_quality: T.nilable(T.any(Models::Components::DirectUploadResponseMediaQuality, String)), source_access: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean)).void }
         def initialize(playback_ids: nil, metadata: nil, media_quality: nil, source_access: nil, optimize_audio: nil)
           @playback_ids = playback_ids
           @metadata = metadata

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

@@ -27,7 +27,7 @@ module FastpixClient
         # 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::GenerateTrackResponseType), language_code: T.nilable(Models::Components::GenerateTrackResponseLanguageCode), language_name: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), type: T.nilable(T.any(Models::Components::GenerateTrackResponseType, String)), language_code: T.nilable(T.any(Models::Components::GenerateTrackResponseLanguageCode, String)), language_name: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String)).void }
         def initialize(id: nil, type: nil, language_code: nil, language_name: nil, metadata: nil, title: nil)
           @id = id
           @type = type

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

@@ -40,8 +40,8 @@ module FastpixClient
         field :named_entities, Crystalline::Nilable.new(Models::Components::AiResponseRecord), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('namedEntities') } }
         # Represents an AI response record containing status and data for AI-generated features like summary, chapters, named entities, or moderation.
         field :moderation, Crystalline::Nilable.new(Models::Components::AiResponseRecord), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('moderation') } }
-        # The length of the media in seconds, with a maximum allowed duration of 12 hours per individual media.
-        field :duration, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
+        # Duration of the media in seconds.
+        field :duration, Crystalline::Nilable.new(::Float), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
         # Frame rate quantifies the speed at which frames are displayed per second. It represents the range of frames available for a specific track. The indeterminable frame rate of the input file is indicated by a value of -1.
         field :frame_rate, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('frameRate') } }
         # Time the media was created, defined as a localDateTime (UTC Time).
@@ -72,7 +72,7 @@ module FastpixClient
         # The aspect ratio of a video is a value that describes the relative shape of a video based on its width and height.
         field :aspect_ratio, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('aspectRatio') } }
 
-        sig { params(id: T.nilable(::String), source_media_id: T.nilable(::String), workspace_id: T.nilable(::String), stream_id: T.nilable(::String), media_quality: T.nilable(Models::Components::GetAllMediaResponseMediaQuality), creator_id: T.nilable(::String), status: T.nilable(Models::Components::GetAllMediaResponseStatus), mp4_support: T.nilable(T::Array[Models::Components::GetAllMediaResponseMp4Support]), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrackForGetAll, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), summary: T.nilable(Models::Components::AiSummaryRecord), chapters: T.nilable(Models::Components::AiResponseRecord), named_entities: T.nilable(Models::Components::AiResponseRecord), moderation: T.nilable(Models::Components::AiResponseRecord), duration: T.nilable(::String), frame_rate: T.nilable(::String), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String), max_resolution: T.nilable(Models::Components::GetAllMediaResponseMaxResolution), source_resolution: T.nilable(Models::Components::GetAllMediaResponseSourceResolution), source_access: T.nilable(T::Boolean), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), source_media_id: T.nilable(::String), workspace_id: T.nilable(::String), stream_id: T.nilable(::String), media_quality: T.nilable(T.any(Models::Components::GetAllMediaResponseMediaQuality, String)), creator_id: T.nilable(::String), status: T.nilable(T.any(Models::Components::GetAllMediaResponseStatus, String)), mp4_support: T.nilable(T::Array[Models::Components::GetAllMediaResponseMp4Support]), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrackForGetAll, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), summary: T.nilable(Models::Components::AiSummaryRecord), chapters: T.nilable(Models::Components::AiResponseRecord), named_entities: T.nilable(Models::Components::AiResponseRecord), moderation: T.nilable(Models::Components::AiResponseRecord), duration: T.nilable(::Float), frame_rate: T.nilable(::String), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String), max_resolution: T.nilable(T.any(Models::Components::GetAllMediaResponseMaxResolution, String)), source_resolution: T.nilable(T.any(Models::Components::GetAllMediaResponseSourceResolution, String)), source_access: T.nilable(T::Boolean), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
         def initialize(id: nil, source_media_id: nil, workspace_id: nil, stream_id: nil, media_quality: nil, creator_id: nil, status: nil, mp4_support: nil, playback_ids: nil, tracks: nil, summary: nil, chapters: nil, named_entities: nil, moderation: nil, duration: nil, frame_rate: nil, created_at: nil, updated_at: nil, thumbnail: nil, metadata: nil, title: nil, max_resolution: Models::Components::GetAllMediaResponseMaxResolution::ONE_THOUSAND_AND_EIGHTYP, source_resolution: Models::Components::GetAllMediaResponseSourceResolution::ONE_THOUSAND_AND_EIGHTYP, source_access: nil, generated_subtitles: nil, is_audio_only: nil, subtitle_available: nil, optimize_audio: nil, aspect_ratio: nil)
           @id = id
           @source_media_id = source_media_id

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

@@ -37,7 +37,7 @@ class FastpixClient::Models::Components::GetAllMediaResponse
   def moderation(); end
   def moderation=(str_); end
   def duration(); end
-  def duration=(str_); end
+  def duration=(float_); end
   def frame_rate(); end
   def frame_rate=(str_); end
   def created_at(); end

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

@@ -40,8 +40,8 @@ module FastpixClient
         field :named_entities, Crystalline::Nilable.new(Models::Components::AiResponseRecord), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('namedEntities') } }
         # Represents an AI response record containing status and data for AI-generated features like summary, chapters, named entities, or moderation.
         field :moderation, Crystalline::Nilable.new(Models::Components::AiResponseRecord), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('moderation') } }
-        # The length of the media in seconds, with a maximum allowed duration of 12 hours per individual media.
-        field :duration, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
+        # Duration of the media in seconds.
+        field :duration, Crystalline::Nilable.new(::Float), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
         # Frame rate quantifies the speed at which frames are displayed per second. It represents the range of frames available for a specific track. The indeterminable frame rate of the input file is indicated by a value of -1.
         field :frame_rate, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('frameRate') } }
         # Time the media was created, defined as a localDateTime (UTC Time).
@@ -72,7 +72,7 @@ module FastpixClient
         # The aspect ratio of a video is a value that describes the relative shape of a video based on its width and height.
         field :aspect_ratio, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('aspectRatio') } }
 
-        sig { params(id: T.nilable(::String), source_media_id: T.nilable(::String), workspace_id: T.nilable(::String), stream_id: T.nilable(::String), media_quality: T.nilable(Models::Components::GetMediaDetailResponseMediaQuality), creator_id: T.nilable(::String), status: T.nilable(Models::Components::GetMediaDetailResponseStatus), mp4_support: T.nilable(T::Array[Models::Components::GetMediaDetailResponseMp4Support]), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), summary: T.nilable(Models::Components::AiSummaryRecord), chapters: T.nilable(Models::Components::AiResponseRecord), named_entities: T.nilable(Models::Components::AiResponseRecord), moderation: T.nilable(Models::Components::AiResponseRecord), duration: T.nilable(::String), frame_rate: T.nilable(::String), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String), max_resolution: T.nilable(Models::Components::GetMediaDetailResponseMaxResolution), source_resolution: T.nilable(Models::Components::GetMediaDetailResponseSourceResolution), source_access: T.nilable(T::Boolean), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), source_media_id: T.nilable(::String), workspace_id: T.nilable(::String), stream_id: T.nilable(::String), media_quality: T.nilable(T.any(Models::Components::GetMediaDetailResponseMediaQuality, String)), creator_id: T.nilable(::String), status: T.nilable(T.any(Models::Components::GetMediaDetailResponseStatus, String)), mp4_support: T.nilable(T::Array[Models::Components::GetMediaDetailResponseMp4Support]), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), summary: T.nilable(Models::Components::AiSummaryRecord), chapters: T.nilable(Models::Components::AiResponseRecord), named_entities: T.nilable(Models::Components::AiResponseRecord), moderation: T.nilable(Models::Components::AiResponseRecord), duration: T.nilable(::Float), frame_rate: T.nilable(::String), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String), max_resolution: T.nilable(T.any(Models::Components::GetMediaDetailResponseMaxResolution, String)), source_resolution: T.nilable(T.any(Models::Components::GetMediaDetailResponseSourceResolution, String)), source_access: T.nilable(T::Boolean), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
         def initialize(id: nil, source_media_id: nil, workspace_id: nil, stream_id: nil, media_quality: nil, creator_id: nil, status: nil, mp4_support: nil, playback_ids: nil, tracks: nil, summary: nil, chapters: nil, named_entities: nil, moderation: nil, duration: nil, frame_rate: nil, created_at: nil, updated_at: nil, thumbnail: nil, metadata: nil, title: nil, max_resolution: Models::Components::GetMediaDetailResponseMaxResolution::ONE_THOUSAND_AND_EIGHTYP, source_resolution: Models::Components::GetMediaDetailResponseSourceResolution::ONE_THOUSAND_AND_EIGHTYP, source_access: nil, generated_subtitles: nil, is_audio_only: nil, subtitle_available: nil, optimize_audio: nil, aspect_ratio: nil)
           @id = id
           @source_media_id = source_media_id

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

@@ -37,7 +37,7 @@ class FastpixClient::Models::Components::GetMediaDetailResponse
   def moderation(); end
   def moderation=(str_); end
   def duration(); end
-  def duration=(str_); end
+  def duration=(float_); end
   def frame_rate(); end
   def frame_rate=(str_); end
   def created_at(); end

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

@@ -19,6 +19,9 @@ module FastpixClient
         # Enables DVR (Digital Video Recorder) functionality, allowing viewers to pause, rewind, and resume live playback.
         # 
         field :enable_dvr_mode, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('enableDvrMode') } }
+        # Controls whether the livestream is recorded to a VOD asset (Live-to-VOD). When true (default), FastPix records and stores the livestream for on-demand viewing. When false, the livestream is not recorded.
+        # 
+        field :enable_recording, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('enableRecording') } }
         # Defines the maximum resolution for encoding, storage, and playback of the live stream.
         # 
         field :max_resolution, Crystalline::Nilable.new(Models::Components::CreateLiveStreamRequestMaxResolution), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('maxResolution'), 'decoder': Utils.enum_from_string(Models::Components::CreateLiveStreamRequestMaxResolution, true) } }
@@ -28,10 +31,11 @@ module FastpixClient
         # Basic access policy for media content
         field :media_policy, Crystalline::Nilable.new(Models::Components::BasicAccessPolicy), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('mediaPolicy'), 'decoder': Utils.enum_from_string(Models::Components::BasicAccessPolicy, true) } }
 
-        sig { params(metadata: T.nilable(T::Hash[Symbol, ::String]), enable_dvr_mode: T.nilable(T::Boolean), max_resolution: T.nilable(Models::Components::CreateLiveStreamRequestMaxResolution), reconnect_window: T.nilable(::Integer), media_policy: T.nilable(Models::Components::BasicAccessPolicy)).void }
-        def initialize(metadata: nil, enable_dvr_mode: nil, max_resolution: Models::Components::CreateLiveStreamRequestMaxResolution::ONE_THOUSAND_AND_EIGHTYP, reconnect_window: 60, media_policy: Models::Components::BasicAccessPolicy::PUBLIC)
+        sig { params(metadata: T.nilable(T::Hash[Symbol, ::String]), enable_dvr_mode: T.nilable(T::Boolean), enable_recording: T.nilable(T::Boolean), max_resolution: T.nilable(Models::Components::CreateLiveStreamRequestMaxResolution), reconnect_window: T.nilable(::Integer), media_policy: T.nilable(Models::Components::BasicAccessPolicy)).void }
+        def initialize(metadata: nil, enable_dvr_mode: nil, enable_recording: true, max_resolution: Models::Components::CreateLiveStreamRequestMaxResolution::ONE_THOUSAND_AND_EIGHTYP, reconnect_window: 60, media_policy: Models::Components::BasicAccessPolicy::PUBLIC)
           @metadata = metadata
           @enable_dvr_mode = enable_dvr_mode
+          @enable_recording = enable_recording
           @max_resolution = max_resolution
           @reconnect_window = reconnect_window
           @media_policy = media_policy
@@ -42,6 +46,7 @@ module FastpixClient
           return false unless other.is_a? self.class
           return false unless @metadata == other.metadata
           return false unless @enable_dvr_mode == other.enable_dvr_mode
+          return false unless @enable_recording == other.enable_recording
           return false unless @max_resolution == other.max_resolution
           return false unless @reconnect_window == other.reconnect_window
           return false unless @media_policy == other.media_policy

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

@@ -12,6 +12,8 @@ class FastpixClient::Models::Components::InputMediaSettings
   def metadata=(str_); end
   def enable_dvr_mode(); end
   def enable_dvr_mode=(str_); end
+  def enable_recording(); end
+  def enable_recording=(str_); end
   def max_resolution(); end
   def max_resolution=(str_); end
   def reconnect_window(); end

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

@@ -30,8 +30,8 @@ module FastpixClient
         field :tracks, Crystalline::Nilable.new(Crystalline::Array.new(Crystalline::Union.new(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack))), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('tracks') } }
         # The MP4 renditions generated for the media. Present only when MP4 support is enabled.
         field :mp4_support, Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::LiveMediaClipsMp4Support)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('mp4Support') } }
-        # The length of the media in seconds, with a maximum allowed duration of 12 hours per individual media.
-        field :duration, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
+        # Duration of the media in seconds.
+        field :duration, Crystalline::Nilable.new(::Float), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
         # Time the media was created, defined as a localDateTime (UTC Time).
         field :created_at, Crystalline::Nilable.new(::DateTime), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('createdAt'), 'decoder': Utils.datetime_from_iso_format(true) } }
         # Time the media was updated, defined as a localDateTime (UTC Time).
@@ -55,7 +55,7 @@ module FastpixClient
         # The aspect ratio of a video is a value that describes the relative shape of a video based on its width and height.
         field :aspect_ratio, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('aspectRatio') } }
 
-        sig { params(id: T.nilable(::String), workspace_id: T.nilable(::String), stream_id: T.nilable(::String), creator_id: T.nilable(::String), status: T.nilable(Models::Components::LiveMediaClipsStatus), source_access: T.nilable(T::Boolean), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), mp4_support: T.nilable(T::Array[Models::Components::LiveMediaClipsMp4Support]), duration: T.nilable(::String), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), title: T.nilable(::String), max_resolution: T.nilable(Models::Components::LiveMediaClipsMaxResolution), source_resolution: T.nilable(Models::Components::LiveMediaClipsSourceResolution), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), workspace_id: T.nilable(::String), stream_id: T.nilable(::String), creator_id: T.nilable(::String), status: T.nilable(T.any(Models::Components::LiveMediaClipsStatus, String)), source_access: T.nilable(T::Boolean), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), mp4_support: T.nilable(T::Array[Models::Components::LiveMediaClipsMp4Support]), duration: T.nilable(::Float), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), title: T.nilable(::String), max_resolution: T.nilable(T.any(Models::Components::LiveMediaClipsMaxResolution, String)), source_resolution: T.nilable(T.any(Models::Components::LiveMediaClipsSourceResolution, String)), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
         def initialize(id: nil, workspace_id: nil, stream_id: nil, creator_id: nil, status: nil, source_access: nil, playback_ids: nil, tracks: nil, mp4_support: nil, duration: nil, created_at: nil, updated_at: nil, thumbnail: nil, title: nil, max_resolution: Models::Components::LiveMediaClipsMaxResolution::ONE_THOUSAND_AND_EIGHTYP, source_resolution: Models::Components::LiveMediaClipsSourceResolution::ONE_THOUSAND_AND_EIGHTYP, generated_subtitles: nil, is_audio_only: nil, subtitle_available: nil, optimize_audio: nil, aspect_ratio: nil)
           @id = id
           @workspace_id = workspace_id

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

@@ -27,7 +27,7 @@ class FastpixClient::Models::Components::LiveMediaClips
   def mp4_support(); end
   def mp4_support=(str_); end
   def duration(); end
-  def duration=(str_); end
+  def duration=(float_); end
   def created_at(); end
   def created_at=(str_); end
   def updated_at(); end

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

@@ -36,8 +36,8 @@ module FastpixClient
         field :named_entities, Crystalline::Nilable.new(Models::Components::AiResponseRecord), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('namedEntities') } }
         # Represents an AI response record containing status and data for AI-generated features like summary, chapters, named entities, or moderation.
         field :moderation, Crystalline::Nilable.new(Models::Components::AiResponseRecord), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('moderation') } }
-        # The length of the media in seconds, with a maximum allowed duration of 12 hours per individual media.
-        field :duration, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
+        # Duration of the media in seconds.
+        field :duration, Crystalline::Nilable.new(::Float), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('duration') } }
         # Time the media was created, defined as a localDateTime (UTC Time).
         field :created_at, Crystalline::Nilable.new(::DateTime), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('createdAt'), 'decoder': Utils.datetime_from_iso_format(true) } }
         # Time the media was updated, defined as a localDateTime (UTC Time).
@@ -66,7 +66,7 @@ module FastpixClient
         # The aspect ratio of a video is a value that describes the relative shape of a video based on its width and height.
         field :aspect_ratio, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('aspectRatio') } }
 
-        sig { params(id: T.nilable(::String), workspace_id: T.nilable(::String), media_quality: T.nilable(Models::Components::MediaMediaQuality), creator_id: T.nilable(::String), status: T.nilable(Models::Components::MediaStatus), mp4_support: T.nilable(T::Array[Models::Components::MediaMp4Support]), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), summary: T.nilable(Models::Components::AiSummaryRecord), chapters: T.nilable(Models::Components::AiResponseRecord), named_entities: T.nilable(Models::Components::AiResponseRecord), moderation: T.nilable(Models::Components::AiResponseRecord), duration: T.nilable(::String), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String), max_resolution: T.nilable(Models::Components::MediaMaxResolution), source_resolution: T.nilable(Models::Components::MediaSourceResolution), source_access: T.nilable(T::Boolean), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
+        sig { params(id: T.nilable(::String), workspace_id: T.nilable(::String), media_quality: T.nilable(T.any(Models::Components::MediaMediaQuality, String)), creator_id: T.nilable(::String), status: T.nilable(T.any(Models::Components::MediaStatus, String)), mp4_support: T.nilable(T::Array[Models::Components::MediaMp4Support]), playback_ids: T.nilable(T::Array[Models::Components::PlaybackId]), tracks: T.nilable(T::Array[T.any(Models::Components::VideoTrack, Models::Components::AudioTrack, Models::Components::SubtitleTrack)]), summary: T.nilable(Models::Components::AiSummaryRecord), chapters: T.nilable(Models::Components::AiResponseRecord), named_entities: T.nilable(Models::Components::AiResponseRecord), moderation: T.nilable(Models::Components::AiResponseRecord), duration: T.nilable(::Float), created_at: T.nilable(::DateTime), updated_at: T.nilable(::DateTime), thumbnail: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), title: T.nilable(::String), max_resolution: T.nilable(T.any(Models::Components::MediaMaxResolution, String)), source_resolution: T.nilable(T.any(Models::Components::MediaSourceResolution, String)), source_access: T.nilable(T::Boolean), generated_subtitles: T.nilable(T::Array[Models::Components::TracksSubtitles]), is_audio_only: T.nilable(T::Boolean), subtitle_available: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), aspect_ratio: T.nilable(::String)).void }
         def initialize(id: nil, workspace_id: nil, media_quality: nil, creator_id: nil, status: nil, mp4_support: nil, playback_ids: nil, tracks: nil, summary: nil, chapters: nil, named_entities: nil, moderation: nil, duration: nil, created_at: nil, updated_at: nil, thumbnail: nil, metadata: nil, title: nil, max_resolution: Models::Components::MediaMaxResolution::ONE_THOUSAND_AND_EIGHTYP, source_resolution: Models::Components::MediaSourceResolution::ONE_THOUSAND_AND_EIGHTYP, source_access: nil, generated_subtitles: nil, is_audio_only: nil, subtitle_available: nil, optimize_audio: nil, aspect_ratio: nil)
           @id = id
           @workspace_id = workspace_id

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

@@ -33,7 +33,7 @@ class FastpixClient::Models::Components::Media
   def moderation(); end
   def moderation=(str_); end
   def duration(); end
-  def duration=(str_); end
+  def duration=(float_); end
   def created_at(); end
   def created_at=(str_); end
   def updated_at(); end