plex_ruby_sdk 0.8.1 → 0.10.0

data/lib/plex_ruby_sdk/utils/utils.rb

@@ -24,7 +24,7 @@ module PlexRubySDK
       end
     end
 
-    sig { params(headers_params: ::Crystalline::FieldAugmented, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, String]) }
+    sig { params(headers_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, String]) }
     def self.get_headers(headers_params, gbls = nil)
       return {} if headers_params.nil?
 
@@ -231,7 +231,7 @@ module PlexRubySDK
       _populate_form(field_name, metadata.fetch(:explode, true), obj, delimiter, &get_query_param_field_name)
     end
 
-    sig { params(clazz: Class, query_params: ::Crystalline::FieldAugmented, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, T::Array[String]]) }
+    sig { params(clazz: Class, query_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, T::Array[String]]) }
     def self.get_query_params(clazz, query_params, gbls = nil)
       params = {}
       param_fields = clazz.fields
@@ -275,7 +275,7 @@ module PlexRubySDK
       params
     end
 
-    sig { params(clazz: Class, server_url: String, path: String, path_params: ::Crystalline::FieldAugmented, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(String) }
+    sig { params(clazz: Class, server_url: String, path: String, path_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(String) }
     def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
       clazz.fields.each do |f|
         param_metadata = f.metadata[:path_param]
@@ -372,6 +372,17 @@ module PlexRubySDK
       false
     end
 
+    sig { params(status_code: Integer, status_codes: T::Array[String]).returns(T::Boolean) }
+    def self.match_status_code(status_code, status_codes)
+      return true if status_codes.include? 'default'
+      status_code = status_code.to_s
+      status_codes.each do |code|
+        return true if code == status_code
+        return true if code.end_with?('xx') && status_code[0..1] == code[0..1]
+      end
+      false
+    end
+
     sig { params(req: Faraday::Request, security: Object).void }
     def self.configure_request_security(req, security)
       return if security.nil?
@@ -468,7 +479,7 @@ module PlexRubySDK
       end
     end
 
-    sig { params(req: Faraday::Request, scheme: ::Crystalline::FieldAugmented).void }
+    sig { params(req: Faraday::Request, scheme: Object).void }
     def self._parse_basic_auth_scheme(req, scheme)
       username, password = ''
 
@@ -564,7 +575,7 @@ module PlexRubySDK
         .returns([String, Object, T.nilable(T::Array[T::Array[Object]])])
     end
     def self.serialize_content_type(field_name, media_type, request)
-      return media_type, ::Crystalline.marshal_json_complex(request), nil if media_type.match('(application|text)\/.*?\+*json.*')
+      return media_type, ::Crystalline.to_json(request), nil if media_type.match('(application|text)\/.*?\+*json.*')
       return serialize_multipart_form(media_type, request) if media_type.match('multipart\/.*')
       return media_type, serialize_form_data(field_name, request), nil if media_type.match('application\/x-www-form-urlencoded.*')
       return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)
@@ -572,7 +583,7 @@ module PlexRubySDK
       raise StandardError, "invalid request body type #{type(request)} for mediaType {metadata['media_type']}"
     end
 
-    sig { params(field: ::Crystalline::MetadataFields::Field, data_class: ::Crystalline::FieldAugmented).returns(Object) }
+    sig { params(field: ::Crystalline::MetadataFields::Field, data_class: Object).returns(Object) }
     def self.parse_field(field, data_class)
       field_metadata = field.metadata[:metadata_string]
       return nil if field_metadata.nil?
@@ -583,7 +594,7 @@ module PlexRubySDK
       field_value
     end
 
-    sig { params(media_type: String, request: ::Crystalline::FieldAugmented).returns([String, Object, T::Array[T::Array[Object]]]) }
+    sig { params(media_type: String, request: Object).returns([String, Object, T::Array[T::Array[Object]]]) }
     def self.serialize_multipart_form(media_type, request)
       form = []
       request_fields = request.fields
@@ -617,7 +628,7 @@ module PlexRubySDK
         elsif field_metadata[:json] == true
           to_append = [
             field_metadata.fetch(:field_name, field.name), [
-              nil, ::Crystalline.marshal_json_complex(val), 'application/json'
+              nil, ::Crystalline.to_json(val), 'application/json'
             ]
           ]
           form.append(to_append)
@@ -662,7 +673,7 @@ module PlexRubySDK
     end
 
     sig do
-      params(field_name: Symbol, data: T.any(::Crystalline::FieldAugmented, T::Hash[Symbol, String]))
+      params(field_name: Symbol, data: T.any(Object, T::Hash[Symbol, String]))
         .returns(T::Hash[Symbol, Object])
     end
     def self.serialize_form_data(field_name, data)
@@ -687,7 +698,7 @@ module PlexRubySDK
           field_name = metadata.fetch(:field_name, field.name)
 
           if metadata[:json]
-            form[field_name] = ::Crystalline.marshal_json_complex(val)
+            form[field_name] = ::Crystalline.to_json(val)
           else
             if metadata.fetch(:style, 'form') == 'form'
               form = form.merge(

data/lib/plex_ruby_sdk/video.rb

@@ -23,7 +23,7 @@ module PlexRubySDK
     end
 
 
-    sig { params(request: T.nilable(::PlexRubySDK::Operations::GetTimelineRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetTimelineResponse) }
+    sig { params(request: T.nilable(Models::Operations::GetTimelineRequest), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetTimelineResponse) }
     def get_timeline(request, timeout_ms = nil)
       # get_timeline - Get the timeline for a media item
       # Get the timeline for a media item
@@ -31,7 +31,7 @@ module PlexRubySDK
       base_url = Utils.template_url(url, params)
       url = "#{base_url}/:/timeline"
       headers = {}
-      query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetTimelineRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::GetTimelineRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
 
@@ -44,16 +44,17 @@ module PlexRubySDK
 
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
-        oauth2_scopes: nil,
+        oauth2_scopes: [],
         operation_id: 'getTimeline',
         security_source: @sdk_configuration.security_source
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.get(url) do |req|
+        http_response = connection.get(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           req.params = query_params
@@ -69,52 +70,82 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        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: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::GetTimelineResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
-      elsif r.status == 400
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        http_response = @sdk_configuration.hooks.after_success(
+          hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+            hook_ctx: hook_ctx
+          ),
+          response: http_response
+        )
+        return Models::Operations::GetTimelineResponse.new(
+          status_code: http_response.status,
+          content_type: content_type,
+          raw_response: http_response
+        )
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTimelineBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetTimelineBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::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 r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTimelineUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetTimelineUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::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
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::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 ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
 
 
-    sig { params(request: T.nilable(::PlexRubySDK::Operations::StartUniversalTranscodeRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::StartUniversalTranscodeResponse) }
+    sig { params(request: T.nilable(Models::Operations::StartUniversalTranscodeRequest), timeout_ms: T.nilable(Integer)).returns(Models::Operations::StartUniversalTranscodeResponse) }
     def start_universal_transcode(request, timeout_ms = nil)
       # start_universal_transcode - Start Universal Transcode
       # Begin a Universal Transcode Session
@@ -122,7 +153,7 @@ module PlexRubySDK
       base_url = Utils.template_url(url, params)
       url = "#{base_url}/video/:/transcode/universal/start.mpd"
       headers = {}
-      query_params = Utils.get_query_params(::PlexRubySDK::Operations::StartUniversalTranscodeRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::StartUniversalTranscodeRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
 
@@ -135,16 +166,17 @@ module PlexRubySDK
 
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
-        oauth2_scopes: nil,
+        oauth2_scopes: [],
         operation_id: 'startUniversalTranscode',
         security_source: @sdk_configuration.security_source
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.get(url) do |req|
+        http_response = connection.get(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           req.params = query_params
@@ -160,48 +192,78 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        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: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::StartUniversalTranscodeResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
-      elsif r.status == 400
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        http_response = @sdk_configuration.hooks.after_success(
+          hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+            hook_ctx: hook_ctx
+          ),
+          response: http_response
+        )
+        return Models::Operations::StartUniversalTranscodeResponse.new(
+          status_code: http_response.status,
+          content_type: content_type,
+          raw_response: http_response
+        )
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::StartUniversalTranscodeBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::StartUniversalTranscodeBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::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 r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::StartUniversalTranscodeUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::StartUniversalTranscodeUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::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
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::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 ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
   end
 end

data/lib/plex_ruby_sdk/watchlist.rb

@@ -28,7 +28,7 @@ module PlexRubySDK
     end
 
 
-    sig { params(request: T.nilable(::PlexRubySDK::Operations::GetWatchListRequest), server_url: T.nilable(String), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetWatchListResponse) }
+    sig { params(request: T.nilable(Models::Operations::GetWatchListRequest), server_url: T.nilable(String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetWatchListResponse) }
     def get_watch_list(request, server_url = nil, timeout_ms = nil)
       # get_watch_list - Get User Watchlist
       # Get User Watchlist
@@ -36,13 +36,13 @@ module PlexRubySDK
       })
       base_url = server_url if !server_url.nil?
       url = Utils.generate_url(
-        ::PlexRubySDK::Operations::GetWatchListRequest,
+        Models::Operations::GetWatchListRequest,
         base_url,
         '/library/sections/watchlist/{filter}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetWatchListRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::GetWatchListRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
 
@@ -55,16 +55,17 @@ module PlexRubySDK
 
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
-        oauth2_scopes: nil,
+        oauth2_scopes: [],
         operation_id: 'get-watch-list',
         security_source: @sdk_configuration.security_source
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.get(url) do |req|
+        http_response = connection.get(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           req.params = query_params
@@ -80,52 +81,86 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        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: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::GetWatchListResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
+      
+      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')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetWatchListResponseBody)
-          res.object = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetWatchListResponseBody)
+          response = Models::Operations::GetWatchListResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            object: obj
+          )
+
+          return response
+        else
+          raise ::PlexRubySDK::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 r.status == 400
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetWatchListBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetWatchListBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::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 r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetWatchListUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetWatchListUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::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
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::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 ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
   end
 end

data/lib/plex_ruby_sdk.rb

@@ -5,9 +5,6 @@
 
 module PlexRubySDK
   autoload :PlexAPI, 'plex_ruby_sdk/plex_api'
-  autoload :ServerVariables, 'plex_ruby_sdk/server_variables'
-  autoload :Shared, 'plex_ruby_sdk/models/shared'
-  autoload :Operations, 'plex_ruby_sdk/models/operations'
   autoload :Server, 'plex_ruby_sdk/server'
   autoload :Media, 'plex_ruby_sdk/media'
   autoload :Video, 'plex_ruby_sdk/video'
@@ -25,6 +22,12 @@ module PlexRubySDK
   autoload :Sessions, 'plex_ruby_sdk/sessions'
   autoload :Updater, 'plex_ruby_sdk/updater'
   autoload :Users, 'plex_ruby_sdk/users'
+  module Models
+    autoload :ServerVariables, 'plex_ruby_sdk/models/server_variables'
+    autoload :Shared, 'plex_ruby_sdk/models/shared'
+    autoload :Operations, 'plex_ruby_sdk/models/operations'
+    autoload :Errors, 'plex_ruby_sdk/models/errors'
+  end
 end
 
 require_relative 'plex_ruby_sdk/utils/utils'