fastpixapi 1.0.0 → 1.1.0

data/lib/fastpix_client/views.rb

@@ -0,0 +1,475 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'faraday/retry'
+require 'sorbet-runtime'
+require_relative 'sdk_hooks/hooks'
+require_relative 'utils/retries'
+
+module FastpixClient
+  extend T::Sig
+  class Views
+    extend T::Sig
+    
+    # Operations involving views
+
+    sig { params(sdk_config: SDKConfiguration).void }
+    def initialize(sdk_config)
+      @sdk_configuration = sdk_config
+      
+    end
+
+    sig { params(base_url: String, url_variables: T.nilable(T::Hash[Symbol, T.any(String, T::Enum)])).returns(String) }
+    def get_url(base_url:, url_variables: nil)
+      sd_base_url, sd_options = @sdk_configuration.get_server_details
+
+      if base_url.nil?
+        base_url = sd_base_url
+      end
+
+      if url_variables.nil?
+        url_variables = sd_options
+      end
+
+      return Utils.template_url base_url, url_variables
+    end
+
+
+    sig { params(request: Models::Operations::ListVideoViewsRequest, timeout_ms: T.nilable(Integer)).returns(Models::Operations::ListVideoViewsResponse) }
+    def list_video_views(request:, timeout_ms: nil)
+      # list_video_views - List video views
+      # Retrieves a list of video views that fall within the specified filters and have been completed within a defined timespan. It lets you to analyse viewer interactions with your video content effectively. 
+      # 
+      # 
+      # #### How it works
+      # 
+      #   1. Send a `GET` request to this endpoint with the desired query parameters. 
+      # 
+      #   2. Specify the timespan for which you want to retrieve the video views using the `timespan[]` parameter. 
+      # 
+      #   3. Filter the views based on dimensions such as browser, device, video title, viewer ID, etc., using the `filterby[]` parameter. Get the dimensions by calling <a href="https://docs.fastpix.io/reference/list_dimensions">list the dimensions</a> endpoint. 
+      # 
+      #   4. Paginate the results using the `limit` and `offset` parameters. 
+      # 
+      #   5. You can also filter by `viewerId`, `errorCode`, `orderBy` a specific field, and `sortOrder` in ascending or descending order. 
+      # 
+      #   6. You receive a response containing the list of video views matching the specified criteria.
+      # 
+      # Each view in the response includes a unique `viewId`. You can use this `viewId` with the  <a href="https://docs.fastpix.io/reference/get_video_view_details">Get Video View Details</a> endpoint to retrieve more detailed information about that specific view.
+      # 
+      # 
+      # #### Example
+      # 
+      # If you manage a video streaming service and want to analyze content performance across devices and browsers. By calling the List Video Views endpoint with filters such as `browser_name` and `device_type`, you can identify which platforms are most popular with your audience. This information helps optimize content for widely used platforms and troubleshoot playback issues on less common devices.
+      # 
+      # 
+      #   Related guide: <a href="https://docs.fastpix.io/docs/audience-metrics">Audience metrics</a>, <a href="https://docs.fastpix.io/docs/understand-dashboard-ui#1-views-dashboard">Views dashboard</a>
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/data/viewlist"
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      query_params = Utils.get_query_params(Models::Operations::ListVideoViewsRequest, request, nil)
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @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: 'list_video_views',
+        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).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          req.params = query_params
+          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
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/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::ListVideoViewsResponseBody)
+          response = Models::Operations::ListVideoViewsResponse.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 received'
+        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, 'application/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::ListVideoViewsResponse.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 received'
+        end
+      end
+    end
+
+
+    sig { params(view_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetVideoViewDetailsResponse) }
+    def get_video_view_details(view_id:, timeout_ms: nil)
+      # get_video_view_details - Get details of video view
+      # Retrieves detailed information about a specific video view using its unique `viewId`. This provides insights into individual viewer interactions with your video content, helping you enhance user experience and improve engagement with your videos. 
+      # 
+      # To use this endpoint, send `GET` request with the `viewId`. The response includes detailed metrics and attributes related to the specified video view. 
+      # 
+      # 
+      # #### Example
+      # 
+      # If a developer receives a report of a poor viewing experience for a specific user. By using this endpoint with the users `viewId`, the developer can retrieve metrics like buffering duration, playback errors, and session length. This data allows the developer to pinpoint issues (such as poor connectivity or a browser-specific problem) and take steps to improve the user experience.
+      # 
+      # 
+      # Related guide: <a href="https://docs.fastpix.io/page/what-video-data-do-we-capture#/">What Video Data do we capture?</a>
+      request = Models::Operations::GetVideoViewDetailsRequest.new(
+        view_id: view_id
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::GetVideoViewDetailsRequest,
+        base_url,
+        '/data/viewlist/{viewId}',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @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: 'get_video_view_details',
+        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).get(url) do |req|
+          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
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/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::GetVideoViewDetailsResponseBody)
+          response = Models::Operations::GetVideoViewDetailsResponse.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 received'
+        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, 'application/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::GetVideoViewDetailsResponse.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 received'
+        end
+      end
+    end
+
+
+    sig { params(timespan: T.nilable(Models::Operations::ListByTopContentTimespan), filterby: T.nilable(::String), limit: T.nilable(::Integer), timeout_ms: T.nilable(Integer)).returns(Models::Operations::ListByTopContentResponse) }
+    def list_by_top_content(timespan: nil, filterby: nil, limit: nil, timeout_ms: nil)
+      # list_by_top_content - List by top content
+      # Retrieves a list of the top video views that fall within the specified filters and have been completed within a defined timespan. It lets you to identify the most popular content based on viewer interactions. 
+      # 
+      # #### How it works
+      # 
+      #   1. Send a `GET` request to this endpoint with the desired query parameters. 
+      # 
+      #   2. Specify the timespan for which you want to retrieve the top content using the `timespan[]` parameter. 
+      # 
+      #   3. Filter the views based on dimensions such as browser, device, video title, etc., using the `filterby[]` parameter. 
+      # 
+      #   4. You can use `Limit` to control number of top views returned. 
+      # 
+      #   5. You receive a response containing the list of top video views matching the specified criteria.
+      # 
+      # 
+      #   Related guide: <a href="https://docs.fastpix.io/page/how-to-get-top-performing-content">Get top-performing content</a>
+      # 
+      request = Models::Operations::ListByTopContentRequest.new(
+        timespan: timespan,
+        filterby: filterby,
+        limit: limit
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/data/viewlist/top-content"
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      query_params = Utils.get_query_params(Models::Operations::ListByTopContentRequest, request, nil)
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @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: 'list_by_top_content',
+        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).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          req.params = query_params
+          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
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/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::ListByTopContentResponseBody)
+          response = Models::Operations::ListByTopContentResponse.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 received'
+        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, 'application/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::ListByTopContentResponse.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 received'
+        end
+      end
+    end
+  end
+end

data/lib/fastpixapi.rb

@@ -1,37 +1,39 @@
+# Generated code for FastPix API SDK.
+
 # typed: true
 # frozen_string_literal: true
 
-module FastpixApiSDK
-  autoload :Fastpix, 'fastpix_api_sdk/fastpix'
-  autoload :InputVideo, 'fastpix_api_sdk/input_video'
-  autoload :ManageVideos, 'fastpix_api_sdk/manage_videos'
-  autoload :InVideoAIFeatures, 'fastpix_api_sdk/in_video_ai_features'
-  autoload :Playback, 'fastpix_api_sdk/playback'
-  autoload :Playlist, 'fastpix_api_sdk/playlist'
-  autoload :DRMConfigurations, 'fastpix_api_sdk/drm_configurations'
-  autoload :StartLiveStream, 'fastpix_api_sdk/start_live_stream'
-  autoload :ManageLiveStream, 'fastpix_api_sdk/manage_live_stream'
-  autoload :LivePlayback, 'fastpix_api_sdk/live_playback'
-  autoload :SimulcastStream, 'fastpix_api_sdk/simulcast_stream'
-  autoload :SigningKeys, 'fastpix_api_sdk/signing_keys'
-  autoload :Views, 'fastpix_api_sdk/views'
-  autoload :Dimensions, 'fastpix_api_sdk/dimensions'
-  autoload :Metrics, 'fastpix_api_sdk/metrics'
-  autoload :Errors, 'fastpix_api_sdk/errors'
+module FastpixClient
+  autoload :Fastpixapi, 'fastpix_client/fastpixapi'
+  autoload :InputVideo, 'fastpix_client/input_video'
+  autoload :ManageVideos, 'fastpix_client/manage_videos'
+  autoload :InVideoAIFeatures, 'fastpix_client/in_video_ai_features'
+  autoload :Playback, 'fastpix_client/playback'
+  autoload :Playlist, 'fastpix_client/playlist'
+  autoload :DRMConfigurations, 'fastpix_client/drm_configurations'
+  autoload :StartLiveStream, 'fastpix_client/start_live_stream'
+  autoload :ManageLiveStream, 'fastpix_client/manage_live_stream'
+  autoload :LivePlayback, 'fastpix_client/live_playback'
+  autoload :SimulcastStream, 'fastpix_client/simulcast_stream'
+  autoload :SigningKeys, 'fastpix_client/signing_keys'
+  autoload :Views, 'fastpix_client/views'
+  autoload :Dimensions, 'fastpix_client/dimensions'
+  autoload :Metrics, 'fastpix_client/metrics'
+  autoload :Errors, 'fastpix_client/errors'
   module Models
-    autoload :Components, 'fastpix_api_sdk/models/components'
-    autoload :Operations, 'fastpix_api_sdk/models/operations'
-    autoload :Errors, 'fastpix_api_sdk/models/errors'
-    autoload :Callbacks, 'fastpix_api_sdk/models/callbacks'
+    autoload :Components, 'fastpix_client/models/components'
+    autoload :Operations, 'fastpix_client/models/operations'
+    autoload :Errors, 'fastpix_client/models/errors'
+    autoload :Callbacks, 'fastpix_client/models/callbacks'
   end
 end
 
-require_relative 'fastpix_api_sdk/utils/utils'
-require_relative 'fastpix_api_sdk/utils/request_bodies'
-require_relative 'fastpix_api_sdk/utils/query_params'
-require_relative 'fastpix_api_sdk/utils/forms'
-require_relative 'fastpix_api_sdk/utils/headers'
-require_relative 'fastpix_api_sdk/utils/url'
-require_relative 'fastpix_api_sdk/utils/security'
+require_relative 'fastpix_client/utils/utils'
+require_relative 'fastpix_client/utils/request_bodies'
+require_relative 'fastpix_client/utils/query_params'
+require_relative 'fastpix_client/utils/forms'
+require_relative 'fastpix_client/utils/headers'
+require_relative 'fastpix_client/utils/url'
+require_relative 'fastpix_client/utils/security'
 require_relative 'crystalline'
-require_relative 'fastpix_api_sdk/sdkconfiguration'
+require_relative 'fastpix_client/sdkconfiguration'

data/lib/openssl_patch.rb

@@ -0,0 +1,70 @@
+# Patch Ruby's OpenSSL to use correct certificate file
+# This file should be required before any SSL connections are made
+
+require 'openssl'
+
+# Find certificate file
+CERT_FILE = if File.exist?('/opt/homebrew/etc/openssl@3/cert.pem')
+              '/opt/homebrew/etc/openssl@3/cert.pem'
+            elsif File.exist?('/usr/local/etc/openssl@3/cert.pem')
+              '/usr/local/etc/openssl@3/cert.pem'
+            elsif File.exist?('/etc/ssl/certs/ca-certificates.crt')
+              '/etc/ssl/certs/ca-certificates.crt'
+            elsif File.exist?('/etc/ssl/cert.pem')
+              '/etc/ssl/cert.pem'
+            else
+              nil
+            end
+
+if CERT_FILE && File.exist?(CERT_FILE)
+  # Patch OpenSSL::X509::Store to always include our certificate file
+  module OpenSSL
+    module X509
+      class Store
+        alias_method :original_set_default_paths, :set_default_paths
+        
+        def set_default_paths
+          original_set_default_paths
+          add_file(CERT_FILE) if CERT_FILE && File.exist?(CERT_FILE)
+        end
+      end
+    end
+  end
+  
+  # Set environment variable for any subprocesses
+  ENV['SSL_CERT_FILE'] = CERT_FILE
+  ENV['REQUESTS_CA_BUNDLE'] = CERT_FILE
+  ENV['CURL_CA_BUNDLE'] = CERT_FILE
+  ENV['RUBY_OPENSSL_CA_CERT_FILE'] = CERT_FILE
+  
+  # Also patch the default certificate file constant if possible
+  if defined?(OpenSSL::X509::DEFAULT_CERT_FILE)
+    OpenSSL::X509::DEFAULT_CERT_FILE.replace(CERT_FILE)
+  end
+  
+  # Patch Net::HTTP to use our certificate store
+  begin
+    require 'net/http' unless defined?(Net::HTTP)
+    
+    module Net
+      class HTTP
+        alias_method :original_connect, :connect
+        
+        def connect
+          original_connect
+          # Ensure SSL context uses our certificate file (skip if context is frozen, e.g. Bundler)
+          if use_ssl? && @ssl_context && !@ssl_context.frozen?
+            store = OpenSSL::X509::Store.new
+            store.set_default_paths
+            store.add_file(CERT_FILE) if CERT_FILE && File.exist?(CERT_FILE)
+            @ssl_context.cert_store = store
+          end
+        end
+      end
+    end
+  rescue LoadError
+    # Net::HTTP not available, skip
+  end
+  
+  puts "[OpenSSL Patch] Configured SSL certificate: #{CERT_FILE}" if ENV['DEBUG']
+end

data/test/sdk_examples_test.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'fastpixapi'
+
+Models = ::FastpixClient::Models
+s = ::FastpixClient::Fastpixapi.new(
+      security: Models::Components::Security.new(
+    username: 'your-access-token',
+    password: 'your-secret-key'
+      ),
+    )
+
+res = s.manage_videos.list_media(limit: 20, offset: 1, order_by: Models::Components::SortOrder::DESC)
+
+begin
+  puts JSON.pretty_generate(JSON.parse(res.raw_response.body))
+rescue FastpixClient::Models::Errors::APIError => e
+  puts JSON.pretty_generate(JSON.parse(e.body))
+rescue StandardError
+  puts res.raw_response.body.to_s
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'json'
+require 'minitest/autorun'
+require 'fastpixapi'
+
+# Standard response handling for any SDK operation. Prints only the JSON body.
+#   res = s.input_video.create_media(request: req)
+#   print_response(res)
+def print_response(res)
+  begin
+    puts JSON.pretty_generate(JSON.parse(res.raw_response.body))
+  rescue StandardError
+    puts res.raw_response.body.to_s
+  end
+end
+
+# Standard error handling when the SDK raises APIError (4xx/5xx). Prints only the JSON body.
+#   rescue FastpixClient::Models::Errors::APIError => e
+#     print_api_error(e)
+def print_api_error(err)
+  begin
+    puts JSON.pretty_generate(JSON.parse(err.body))
+  rescue StandardError
+    puts err.body.to_s
+  end
+end