fastpixapi 0.0.1 → 1.1.0

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

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Components::ChaptersResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Components::ChaptersResponse
+  def media_id(); end
+  def media_id=(str_); end
+  def is_chapters_enabled(); end
+  def is_chapters_enabled=(str_); end
+end

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

@@ -0,0 +1,36 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+
+      class CreateLiveStreamRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Displays the result of the playback settings.
+        field :playback_settings, Models::Components::PlaybackSettings, { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('playbackSettings'), required: true } }
+        # Contains configuration details for input media settings.
+        field :input_media_settings, Models::Components::InputMediaSettings, { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('inputMediaSettings'), required: true } }
+
+        sig { params(playback_settings: Models::Components::PlaybackSettings, input_media_settings: Models::Components::InputMediaSettings).void }
+        def initialize(playback_settings:, input_media_settings:)
+          @playback_settings = playback_settings
+          @input_media_settings = input_media_settings
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @playback_settings == other.playback_settings
+          return false unless @input_media_settings == other.input_media_settings
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Components::CreateLiveStreamRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Components::CreateLiveStreamRequest
+  def playback_settings(); end
+  def playback_settings=(str_); end
+  def input_media_settings(); end
+  def input_media_settings=(str_); end
+end

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

@@ -0,0 +1,23 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+      # CreateLiveStreamRequestMaxResolution - Defines the maximum resolution for encoding, storage, and playback of the live stream.
+      # 
+      class CreateLiveStreamRequestMaxResolution < T::Enum
+
+
+        enums do
+          ONE_THOUSAND_AND_EIGHTYP = new('1080p')
+          SEVEN_HUNDRED_AND_TWENTYP = new('720p')
+          FOUR_HUNDRED_AND_EIGHTYP = new('480p')
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,96 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+      # Displays the result of the request.
+      class CreateLiveStreamResponseDTO
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Upon creating a new live stream, FastPix assigns a unique identifier to the stream.
+        field :stream_id, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('streamId') } }
+        # A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
+        field :stream_key, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('streamKey') } }
+        # A secret used for securing the SRT stream. This ensures that only authorized users can access the stream.
+        field :srt_secret, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('srtSecret') } }
+        # FastPix allows for a to trial the live stream for free. The duration of trial streams is five minutes. After five minutes of activity, the trial stream is turned off, and the recorded asset is removed after a day.
+        field :trial, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('trial') } }
+        # The current live stream status can be one of four values:Idle, Preparing, Active or Disabled.The Idle status signifies that there isn"t a broadcast in progress.The preparing status indicates that the stream is getting prepared. while, the Active status indicates that a broadcast is currently in progress. The Disabled status means that no more RTMPS streams can be published.
+        field :status, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('status') } }
+        # Max resolution can be used to control the maximum resolution your media is encoded, stored, and streamed at.
+        field :max_resolution, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('maxResolution') } }
+        # The maximum duration in seconds that a live stream can have before it ends the stream.
+        field :max_duration, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('maxDuration') } }
+        # It is the moment when the stream was created Time the media was generated, 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) } }
+        # When set to true, the livestream will be recorded and stored for later viewing purposes. If set to false, the livestream will not be recorded.
+        field :enable_recording, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('enableRecording') } }
+        # Enables DVR (Digital Video Recorder) functionality for the live stream. When set to true, viewers can pause, rewind, and resume playback during the live broadcast. This allows time-shifted viewing of the stream while it is still ongoing.
+        field :enable_dvr_mode, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('enableDvrMode') } }
+        # Determines whether the recorded stream should be publicly accessible or private in Live to VOD (Video on Demand).
+        field :media_policy, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('mediaPolicy') } }
+        # You can search for videos with specific key value pairs using metadata, when you tag a video in "key":"value"s pairs. Dynamic metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
+        field :metadata, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('metadata') } }
+        # Enables low-latency streaming mode to reduce playback delay.
+        field :low_latency, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('lowLatency') } }
+        # when provided true Enables closed captions for the livestream.
+        field :closed_captions, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('closedCaptions') } }
+        # A collection of Playback ID objects utilized for crafting HLS playback urls.
+        field :playback_ids, Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::PlaybackIdResponse)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('playbackIds') } }
+        # This object contains the livestream playback response details for SRT Protocol
+        field :srt_playback_response, Crystalline::Nilable.new(Models::Components::SrtPlaybackResponse), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('srtPlaybackResponse') } }
+        # In case the software streaming the live, gets disrupted for any reason and gets disconnected from FastPix, the reconnect window specifies the time span FastPix will wait before ending the stream. Before starting the stream, you can set the reconnect window time which is up to 1800 seconds.
+        field :reconnect_window, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('reconnectWindow') } }
+
+        sig { params(stream_id: T.nilable(::String), stream_key: T.nilable(::String), srt_secret: T.nilable(::String), trial: T.nilable(T::Boolean), status: T.nilable(::String), max_resolution: T.nilable(::String), max_duration: T.nilable(::Integer), created_at: T.nilable(::DateTime), enable_recording: T.nilable(T::Boolean), enable_dvr_mode: T.nilable(T::Boolean), media_policy: T.nilable(::String), metadata: T.nilable(T::Hash[Symbol, ::String]), low_latency: T.nilable(T::Boolean), closed_captions: T.nilable(T::Boolean), playback_ids: T.nilable(T::Array[Models::Components::PlaybackIdResponse]), srt_playback_response: T.nilable(Models::Components::SrtPlaybackResponse), reconnect_window: T.nilable(::Integer)).void }
+        def initialize(stream_id: nil, stream_key: nil, srt_secret: nil, trial: nil, status: nil, max_resolution: nil, max_duration: nil, created_at: nil, enable_recording: nil, enable_dvr_mode: nil, media_policy: nil, metadata: nil, low_latency: nil, closed_captions: nil, playback_ids: nil, srt_playback_response: nil, reconnect_window: 60)
+          @stream_id = stream_id
+          @stream_key = stream_key
+          @srt_secret = srt_secret
+          @trial = trial
+          @status = status
+          @max_resolution = max_resolution
+          @max_duration = max_duration
+          @created_at = created_at
+          @enable_recording = enable_recording
+          @enable_dvr_mode = enable_dvr_mode
+          @media_policy = media_policy
+          @metadata = metadata
+          @low_latency = low_latency
+          @closed_captions = closed_captions
+          @playback_ids = playback_ids
+          @srt_playback_response = srt_playback_response
+          @reconnect_window = reconnect_window
+        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 @stream_key == other.stream_key
+          return false unless @srt_secret == other.srt_secret
+          return false unless @trial == other.trial
+          return false unless @status == other.status
+          return false unless @max_resolution == other.max_resolution
+          return false unless @max_duration == other.max_duration
+          return false unless @created_at == other.created_at
+          return false unless @enable_recording == other.enable_recording
+          return false unless @enable_dvr_mode == other.enable_dvr_mode
+          return false unless @media_policy == other.media_policy
+          return false unless @metadata == other.metadata
+          return false unless @low_latency == other.low_latency
+          return false unless @closed_captions == other.closed_captions
+          return false unless @playback_ids == other.playback_ids
+          return false unless @srt_playback_response == other.srt_playback_response
+          return false unless @reconnect_window == other.reconnect_window
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Components::CreateLiveStreamResponseDTO
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Components::CreateLiveStreamResponseDTO
+  def stream_id(); end
+  def stream_id=(str_); end
+  def stream_key(); end
+  def stream_key=(str_); end
+  def srt_secret(); end
+  def srt_secret=(str_); end
+  def trial(); end
+  def trial=(str_); end
+  def status(); end
+  def status=(str_); end
+  def max_resolution(); end
+  def max_resolution=(str_); end
+  def max_duration(); end
+  def max_duration=(str_); end
+  def created_at(); end
+  def created_at=(str_); end
+  def enable_recording(); end
+  def enable_recording=(str_); end
+  def enable_dvr_mode(); end
+  def enable_dvr_mode=(str_); end
+  def media_policy(); end
+  def media_policy=(str_); end
+  def metadata(); end
+  def metadata=(str_); end
+  def low_latency(); end
+  def low_latency=(str_); end
+  def closed_captions(); end
+  def closed_captions=(str_); end
+  def playback_ids(); end
+  def playback_ids=(str_); end
+  def srt_playback_response(); end
+  def srt_playback_response=(str_); end
+  def reconnect_window(); end
+  def reconnect_window=(str_); end
+end

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

@@ -0,0 +1,106 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+
+      class CreateMediaRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Add one input object at a time. For example, first add a **VideoInput** object.   If you also need a watermark, click **Add item** again and select **WatermarkInput**.   Repeat this process for **AudioInput** or **SubtitleInput** as needed. For a complete explanation of how media uploads from URL and processing work, refer to the  
+        #         <a href="https://docs.fastpix.io/docs/video-on-demand-overview" target="_blank">FastPix Video on Demand Overview</a>.
+        # 
+        field :inputs, Crystalline::Array.new(Crystalline::Union.new(Models::Components::PullVideoInput, Models::Components::WatermarkInput, Models::Components::AudioInput, Models::Components::SubtitleInput)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('inputs'), required: true } }
+        # You can search for videos with specific key value pairs using metadata, when you tag a video in "key" : "value" pairs. Dynamic metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
+        # 
+        field :metadata, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('metadata') } }
+        # UUID of the DRM configuration to be used
+        field :drm_configuration_id, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('drmConfigurationId') } }
+        # Title of the media file.
+        field :title, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('title') } }
+        # The unique identifier of the user who created this media.
+        field :creator_id, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('creatorId') } }
+        # Generates subtitle files for audio/video files.
+        # 
+        field :subtitles, Crystalline::Nilable.new(Models::Components::Subtitles), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('subtitles') } }
+        # "capped_4k": Generates an mp4 video file up to 4k resolution "audioOnly": Generates an m4a audio file of the media file "audioOnly,capped_4k": Generates both video and audio media files for offline viewing
+        # 
+        field :mp4_support, Crystalline::Nilable.new(Models::Components::CreateMediaRequestMp4Support), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('mp4Support'), 'decoder': Utils.enum_from_string(Models::Components::CreateMediaRequestMp4Support, true) } }
+        # The sourceAccess parameter determines whether the original media file is accessible. Set to true to enable access or false to restrict it
+        field :source_access, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('sourceAccess') } }
+        # normalize volume of the audio track. This is available for pre-recorded content only.
+        # 
+        field :optimize_audio, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('optimizeAudio') } }
+
+        field :summary, Crystalline::Nilable.new(Models::Components::Summary), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('summary') } }
+        # Enable or disable the chapters feature for the media. Set to `true` to enable chapters or `false` to disable.
+        # 
+        field :chapters, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('chapters') } }
+        # Enable or disable named entity extraction. Set to `true` to enable or `false` to disable.
+        # 
+        field :named_entities, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('namedEntities') } }
+
+        field :moderation, Crystalline::Nilable.new(Models::Components::Moderation), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('moderation') } }
+
+        field :access_restrictions, Crystalline::Nilable.new(Models::Components::CreateMediaRequestAccessRestrictions), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('accessRestrictions') } }
+        # Determines whether access to the streamed content is kept private or available to all.
+        # 
+        field :access_policy, Crystalline::Nilable.new(Models::Components::CreateMediaRequestAccessPolicy), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('accessPolicy'), 'decoder': Utils.enum_from_string(Models::Components::CreateMediaRequestAccessPolicy, true) } }
+        # The maximum resolution tier defines the highest quality at which your media is available.
+        # 
+        field :max_resolution, Crystalline::Nilable.new(Models::Components::CreateMediaRequestMaxResolution), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('maxResolution'), 'decoder': Utils.enum_from_string(Models::Components::CreateMediaRequestMaxResolution, true) } }
+        # The quality tier applied to the media.
+        field :media_quality, Crystalline::Nilable.new(Models::Components::CreateMediaRequestMediaQuality), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('mediaQuality'), 'decoder': Utils.enum_from_string(Models::Components::CreateMediaRequestMediaQuality, true) } }
+
+        sig { params(inputs: T::Array[T.any(Models::Components::PullVideoInput, Models::Components::WatermarkInput, Models::Components::AudioInput, Models::Components::SubtitleInput)], metadata: T.nilable(T::Hash[Symbol, ::String]), drm_configuration_id: T.nilable(::String), title: T.nilable(::String), creator_id: T.nilable(::String), subtitles: T.nilable(Models::Components::Subtitles), mp4_support: T.nilable(Models::Components::CreateMediaRequestMp4Support), source_access: T.nilable(T::Boolean), optimize_audio: T.nilable(T::Boolean), summary: T.nilable(Models::Components::Summary), chapters: T.nilable(T::Boolean), named_entities: T.nilable(T::Boolean), moderation: T.nilable(Models::Components::Moderation), access_restrictions: T.nilable(Models::Components::CreateMediaRequestAccessRestrictions), access_policy: T.nilable(Models::Components::CreateMediaRequestAccessPolicy), max_resolution: T.nilable(Models::Components::CreateMediaRequestMaxResolution), media_quality: T.nilable(Models::Components::CreateMediaRequestMediaQuality)).void }
+        def initialize(inputs:, metadata: nil, drm_configuration_id: nil, title: nil, creator_id: nil, subtitles: nil, mp4_support: nil, source_access: nil, optimize_audio: nil, summary: nil, chapters: nil, named_entities: nil, moderation: nil, access_restrictions: nil, access_policy: Models::Components::CreateMediaRequestAccessPolicy::PUBLIC, max_resolution: Models::Components::CreateMediaRequestMaxResolution::ONE_THOUSAND_AND_EIGHTYP, media_quality: Models::Components::CreateMediaRequestMediaQuality::STANDARD)
+          @inputs = inputs
+          @metadata = metadata
+          @drm_configuration_id = drm_configuration_id
+          @title = title
+          @creator_id = creator_id
+          @subtitles = subtitles
+          @mp4_support = mp4_support
+          @source_access = source_access
+          @optimize_audio = optimize_audio
+          @summary = summary
+          @chapters = chapters
+          @named_entities = named_entities
+          @moderation = moderation
+          @access_restrictions = access_restrictions
+          @access_policy = access_policy
+          @max_resolution = max_resolution
+          @media_quality = media_quality
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @inputs == other.inputs
+          return false unless @metadata == other.metadata
+          return false unless @drm_configuration_id == other.drm_configuration_id
+          return false unless @title == other.title
+          return false unless @creator_id == other.creator_id
+          return false unless @subtitles == other.subtitles
+          return false unless @mp4_support == other.mp4_support
+          return false unless @source_access == other.source_access
+          return false unless @optimize_audio == other.optimize_audio
+          return false unless @summary == other.summary
+          return false unless @chapters == other.chapters
+          return false unless @named_entities == other.named_entities
+          return false unless @moderation == other.moderation
+          return false unless @access_restrictions == other.access_restrictions
+          return false unless @access_policy == other.access_policy
+          return false unless @max_resolution == other.max_resolution
+          return false unless @media_quality == other.media_quality
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Components::CreateMediaRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Components::CreateMediaRequest
+  def inputs(); end
+  def inputs=(str_); end
+  def metadata(); end
+  def metadata=(str_); end
+  def drm_configuration_id(); end
+  def drm_configuration_id=(str_); end
+  def title(); end
+  def title=(str_); end
+  def creator_id(); end
+  def creator_id=(str_); end
+  def subtitles(); end
+  def subtitles=(str_); end
+  def mp4_support(); end
+  def mp4_support=(str_); end
+  def source_access(); end
+  def source_access=(str_); end
+  def optimize_audio(); end
+  def optimize_audio=(str_); end
+  def summary(); end
+  def summary=(str_); end
+  def chapters(); end
+  def chapters=(str_); end
+  def named_entities(); end
+  def named_entities=(str_); end
+  def moderation(); end
+  def moderation=(str_); end
+  def access_restrictions(); end
+  def access_restrictions=(str_); end
+  def access_policy(); end
+  def access_policy=(str_); end
+  def max_resolution(); end
+  def max_resolution=(str_); end
+  def media_quality(); end
+  def media_quality=(str_); end
+end

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

@@ -0,0 +1,23 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+      # CreateMediaRequestAccessPolicy - Determines whether access to the streamed content is kept private or available to all.
+      # 
+      class CreateMediaRequestAccessPolicy < T::Enum
+
+
+        enums do
+          PUBLIC = new('public')
+          PRIVATE = new('private')
+          DRM = new('drm')
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+
+      class CreateMediaRequestAccessRestrictions
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+
+        field :domains, Crystalline::Nilable.new(Models::Components::CreateMediaRequestDomains), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('domains') } }
+
+        field :user_agents, Crystalline::Nilable.new(Models::Components::CreateMediaRequestUserAgents), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('userAgents') } }
+
+        sig { params(domains: T.nilable(Models::Components::CreateMediaRequestDomains), user_agents: T.nilable(Models::Components::CreateMediaRequestUserAgents)).void }
+        def initialize(domains: nil, user_agents: nil)
+          @domains = domains
+          @user_agents = user_agents
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @domains == other.domains
+          return false unless @user_agents == other.user_agents
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Components::CreateMediaRequestAccessRestrictions
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Components::CreateMediaRequestAccessRestrictions
+  def domains(); end
+  def domains=(str_); end
+  def user_agents(); end
+  def user_agents=(str_); end
+end

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

@@ -0,0 +1,47 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+
+      class CreateMediaRequestDomains
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Specifies the default access policy for domains. 
+        # If set to `allow`, all domains are allowed access unless otherwise specified in the `deny` lists. 
+        # If set to `deny`, all domains are denied access unless otherwise specified in the `allow` lists.
+        # 
+        field :default_policy, Crystalline::Nilable.new(Models::Components::DomainsDefaultPolicy), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('defaultPolicy'), 'decoder': Utils.enum_from_string(Models::Components::DomainsDefaultPolicy, true) } }
+        # A list of domain names or patterns that are explicitly allowed access. 
+        # This list is only effective when the `defaultPolicy` is set to `deny`.
+        # 
+        field :allow, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::FastpixClient::Utils.field_name('allow') } }
+        # A list of domain names or patterns that are explicitly denied access. 
+        # This list is only effective when the `defaultPolicy` is set to `allow`.
+        # 
+        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::DomainsDefaultPolicy), 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/components/createmediarequest_domains.rbi

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class FastpixClient::Models::Components::CreateMediaRequestDomains
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class FastpixClient::Models::Components::CreateMediaRequestDomains
+  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/components/createmediarequest_languagecode.rb

@@ -0,0 +1,27 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+      # CreateMediaRequestLanguageCode - Language codes are concise, standardized symbols that denote languages, utilizing either two or three characters for identification. The language code must be compliant with the BCP 47 standard to ensure compatibility. (for text only).
+      # 
+      class CreateMediaRequestLanguageCode < T::Enum
+
+
+        enums do
+          EN = new('en')
+          IT = new('it')
+          PL = new('pl')
+          ES = new('es')
+          FR = new('fr')
+          RU = new('ru')
+          NL = new('nl')
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module FastpixClient
+  module Models
+    module Components
+      # CreateMediaRequestMaxResolution - The maximum resolution tier defines the highest quality at which your media is available.
+      # 
+      class CreateMediaRequestMaxResolution < T::Enum
+
+
+        enums do
+          TWO_THOUSAND_ONE_HUNDRED_AND_SIXTYP = new('2160p')
+          ONE_THOUSAND_FOUR_HUNDRED_AND_FORTYP = new('1440p')
+          ONE_THOUSAND_AND_EIGHTYP = new('1080p')
+          SEVEN_HUNDRED_AND_TWENTYP = new('720p')
+          FOUR_HUNDRED_AND_EIGHTYP = new('480p')
+        end
+      end
+    end
+  end
+end

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

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