mirror of
https://github.com/LukeHagar/plexruby.git
synced 2025-12-07 12:47:45 +00:00
ci: regenerated with OpenAPI Doc , Speakeasy CLI 1.531.4
This commit is contained in:
speakeasybot
@@ -29,7 +29,7 @@ module PlexRubySDK
|
||||
end
|
||||
|
||||
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetServerActivitiesResponse) }
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetServerActivitiesResponse) }
|
||||
def get_server_activities(timeout_ms = nil)
|
||||
# get_server_activities - Get Server Activities
|
||||
# Get Server Activities
|
||||
@@ -55,10 +55,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -73,67 +74,101 @@ 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 = 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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetServerActivitiesResponseBody)
|
||||
response = Models::Operations::GetServerActivitiesResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
object: obj
|
||||
)
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetServerActivitiesBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetServerActivitiesUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetServerActivitiesResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesResponseBody)
|
||||
res.object = out
|
||||
end
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(activity_uuid: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::CancelServerActivitiesResponse) }
|
||||
sig { params(activity_uuid: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::CancelServerActivitiesResponse) }
|
||||
def cancel_server_activities(activity_uuid, timeout_ms = nil)
|
||||
# cancel_server_activities - Cancel Server Activities
|
||||
# Cancel Server Activities
|
||||
request = ::PlexRubySDK::Operations::CancelServerActivitiesRequest.new(
|
||||
request = Models::Operations::CancelServerActivitiesRequest.new(
|
||||
|
||||
activity_uuid: activity_uuid
|
||||
)
|
||||
url, params = @sdk_configuration.get_server_details
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = Utils.generate_url(
|
||||
::PlexRubySDK::Operations::CancelServerActivitiesRequest,
|
||||
Models::Operations::CancelServerActivitiesRequest,
|
||||
base_url,
|
||||
'/activities/{activityUUID}',
|
||||
request
|
||||
@@ -157,10 +192,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.delete(url) do |req|
|
||||
http_response = connection.delete(url) do |req|
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -175,48 +211,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::CancelServerActivitiesResponse.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::CancelServerActivitiesResponse.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::CancelServerActivitiesBadRequest)
|
||||
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::CancelServerActivitiesBadRequest)
|
||||
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::CancelServerActivitiesUnauthorized)
|
||||
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::CancelServerActivitiesUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -33,12 +33,12 @@ module PlexRubySDK
|
||||
end
|
||||
|
||||
|
||||
sig { params(type: ::PlexRubySDK::Operations::GetTransientTokenQueryParamType, scope: ::PlexRubySDK::Operations::Scope, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetTransientTokenResponse) }
|
||||
sig { params(type: Models::Operations::GetTransientTokenQueryParamType, scope: Models::Operations::Scope, timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetTransientTokenResponse) }
|
||||
def get_transient_token(type, scope, timeout_ms = nil)
|
||||
# get_transient_token - Get a Transient Token
|
||||
# This endpoint provides the caller with a temporary token with the same access level as the caller's token. These tokens are valid for up to 48 hours and are destroyed if the server instance is restarted.
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::GetTransientTokenRequest.new(
|
||||
request = Models::Operations::GetTransientTokenRequest.new(
|
||||
|
||||
type: type,
|
||||
scope: scope
|
||||
@@ -47,7 +47,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/security/token"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetTransientTokenRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::GetTransientTokenRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -66,10 +66,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -85,58 +86,88 @@ 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::GetTransientTokenResponse.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::GetTransientTokenResponse.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::GetTransientTokenBadRequest)
|
||||
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::GetTransientTokenBadRequest)
|
||||
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::GetTransientTokenUnauthorized)
|
||||
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::GetTransientTokenUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(source: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetSourceConnectionInformationResponse) }
|
||||
sig { params(source: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetSourceConnectionInformationResponse) }
|
||||
def get_source_connection_information(source, timeout_ms = nil)
|
||||
# get_source_connection_information - Get Source Connection Information
|
||||
# If a caller requires connection details and a transient token for a source that is known to the server, for example a cloud media provider or shared PMS, then this endpoint can be called. This endpoint is only accessible with either an admin token or a valid transient token generated from an admin token.
|
||||
# Note: requires Plex Media Server >= 1.15.4.
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::GetSourceConnectionInformationRequest.new(
|
||||
request = Models::Operations::GetSourceConnectionInformationRequest.new(
|
||||
|
||||
source: source
|
||||
)
|
||||
@@ -144,7 +175,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/security/resources"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetSourceConnectionInformationRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::GetSourceConnectionInformationRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -163,10 +194,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -182,52 +214,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::GetSourceConnectionInformationResponse.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::GetSourceConnectionInformationResponse.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::GetSourceConnectionInformationBadRequest)
|
||||
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::GetSourceConnectionInformationBadRequest)
|
||||
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::GetSourceConnectionInformationUnauthorized)
|
||||
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::GetSourceConnectionInformationUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(server_url: T.nilable(String), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetTokenDetailsResponse) }
|
||||
sig { params(server_url: T.nilable(String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetTokenDetailsResponse) }
|
||||
def get_token_details(server_url = nil, timeout_ms = nil)
|
||||
# get_token_details - Get Token Details
|
||||
# Get the User data from the provided X-Plex-Token
|
||||
@@ -254,10 +316,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -272,56 +335,90 @@ 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 = 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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetTokenDetailsUserPlexAccount)
|
||||
response = Models::Operations::GetTokenDetailsResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
user_plex_account: obj
|
||||
)
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetTokenDetailsBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetTokenDetailsUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetTokenDetailsResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTokenDetailsUserPlexAccount)
|
||||
res.user_plex_account = out
|
||||
end
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTokenDetailsBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetTokenDetailsUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(request: T.nilable(::PlexRubySDK::Operations::PostUsersSignInDataRequest), server_url: T.nilable(String), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::PostUsersSignInDataResponse) }
|
||||
sig { params(request: T.nilable(Models::Operations::PostUsersSignInDataRequest), server_url: T.nilable(String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::PostUsersSignInDataResponse) }
|
||||
def post_users_sign_in_data(request, server_url = nil, timeout_ms = nil)
|
||||
# post_users_sign_in_data - Get User Sign In Data
|
||||
# Sign in user with username and password and return user data with Plex authentication token
|
||||
@@ -356,10 +453,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.post(url) do |req|
|
||||
http_response = connection.post(url) do |req|
|
||||
req.body = body
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
@@ -374,52 +472,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 = http_response.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
if Utils.match_status_code(http_response.status, ['201'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::PostUsersSignInDataUserPlexAccount)
|
||||
response = Models::Operations::PostUsersSignInDataResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
user_plex_account: obj
|
||||
)
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::PostUsersSignInDataBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::PostUsersSignInDataUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::PostUsersSignInDataResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 201
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::PostUsersSignInDataUserPlexAccount)
|
||||
res.user_plex_account = out
|
||||
end
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::PostUsersSignInDataBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::PostUsersSignInDataUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -23,7 +23,7 @@ module PlexRubySDK
|
||||
end
|
||||
|
||||
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetButlerTasksResponse) }
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetButlerTasksResponse) }
|
||||
def get_butler_tasks(timeout_ms = nil)
|
||||
# get_butler_tasks - Get Butler tasks
|
||||
# Returns a list of butler tasks
|
||||
@@ -49,10 +49,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -67,56 +68,90 @@ 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 = 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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetButlerTasksResponseBody)
|
||||
response = Models::Operations::GetButlerTasksResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
object: obj
|
||||
)
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetButlerTasksBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetButlerTasksUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetButlerTasksResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetButlerTasksResponseBody)
|
||||
res.object = out
|
||||
end
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetButlerTasksBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetButlerTasksUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::StartAllTasksResponse) }
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::StartAllTasksResponse) }
|
||||
def start_all_tasks(timeout_ms = nil)
|
||||
# start_all_tasks - Start all Butler tasks
|
||||
# This endpoint will attempt to start all Butler tasks that are enabled in the settings. Butler tasks normally run automatically during a time window configured on the server's Settings page but can be manually started using this endpoint. Tasks will run with the following criteria:
|
||||
@@ -147,10 +182,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.post(url) do |req|
|
||||
http_response = connection.post(url) do |req|
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -165,52 +201,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::StartAllTasksResponse.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::StartAllTasksResponse.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::StartAllTasksBadRequest)
|
||||
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::StartAllTasksBadRequest)
|
||||
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::StartAllTasksUnauthorized)
|
||||
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::StartAllTasksUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::StopAllTasksResponse) }
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::StopAllTasksResponse) }
|
||||
def stop_all_tasks(timeout_ms = nil)
|
||||
# stop_all_tasks - Stop all Butler tasks
|
||||
# This endpoint will stop all currently running tasks and remove any scheduled tasks from the queue.
|
||||
@@ -237,10 +303,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.delete(url) do |req|
|
||||
http_response = connection.delete(url) do |req|
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -255,52 +322,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::StopAllTasksResponse.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::StopAllTasksResponse.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::StopAllTasksBadRequest)
|
||||
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::StopAllTasksBadRequest)
|
||||
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::StopAllTasksUnauthorized)
|
||||
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::StopAllTasksUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(task_name: ::PlexRubySDK::Operations::TaskName, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::StartTaskResponse) }
|
||||
sig { params(task_name: Models::Operations::TaskName, timeout_ms: T.nilable(Integer)).returns(Models::Operations::StartTaskResponse) }
|
||||
def start_task(task_name, timeout_ms = nil)
|
||||
# start_task - Start a single Butler task
|
||||
# This endpoint will attempt to start a single Butler task that is enabled in the settings. Butler tasks normally run automatically during a time window configured on the server's Settings page but can be manually started using this endpoint. Tasks will run with the following criteria:
|
||||
@@ -309,14 +406,14 @@ module PlexRubySDK
|
||||
# 3. If a task is configured to run at a random time during the configured window and we are within that window, the task will be scheduled at a random time within the window.
|
||||
# 4. If we are outside the configured window, the task will start immediately.
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::StartTaskRequest.new(
|
||||
request = Models::Operations::StartTaskRequest.new(
|
||||
|
||||
task_name: task_name
|
||||
)
|
||||
url, params = @sdk_configuration.get_server_details
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = Utils.generate_url(
|
||||
::PlexRubySDK::Operations::StartTaskRequest,
|
||||
Models::Operations::StartTaskRequest,
|
||||
base_url,
|
||||
'/butler/{taskName}',
|
||||
request
|
||||
@@ -340,10 +437,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.post(url) do |req|
|
||||
http_response = connection.post(url) do |req|
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -358,64 +456,94 @@ 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::StartTaskResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if [200, 202].include?(r.status)
|
||||
elsif r.status == 400
|
||||
|
||||
content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
if Utils.match_status_code(http_response.status, ['200', '202'])
|
||||
http_response = @sdk_configuration.hooks.after_success(
|
||||
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
||||
hook_ctx: hook_ctx
|
||||
),
|
||||
response: http_response
|
||||
)
|
||||
return Models::Operations::StartTaskResponse.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::StartTaskBadRequest)
|
||||
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::StartTaskBadRequest)
|
||||
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::StartTaskUnauthorized)
|
||||
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::StartTaskUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(task_name: ::PlexRubySDK::Operations::PathParamTaskName, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::StopTaskResponse) }
|
||||
sig { params(task_name: Models::Operations::PathParamTaskName, timeout_ms: T.nilable(Integer)).returns(Models::Operations::StopTaskResponse) }
|
||||
def stop_task(task_name, timeout_ms = nil)
|
||||
# stop_task - Stop a single Butler task
|
||||
# This endpoint will stop a currently running task by name, or remove it from the list of scheduled tasks if it exists. See the section above for a list of task names for this endpoint.
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::StopTaskRequest.new(
|
||||
request = Models::Operations::StopTaskRequest.new(
|
||||
|
||||
task_name: task_name
|
||||
)
|
||||
url, params = @sdk_configuration.get_server_details
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = Utils.generate_url(
|
||||
::PlexRubySDK::Operations::StopTaskRequest,
|
||||
Models::Operations::StopTaskRequest,
|
||||
base_url,
|
||||
'/butler/{taskName}',
|
||||
request
|
||||
@@ -439,10 +567,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.delete(url) do |req|
|
||||
http_response = connection.delete(url) do |req|
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -457,49 +586,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::StopTaskResponse.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::StopTaskResponse.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::StopTaskBadRequest)
|
||||
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::StopTaskBadRequest)
|
||||
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::StopTaskUnauthorized)
|
||||
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::StopTaskUnauthorized)
|
||||
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 == 404
|
||||
elsif Utils.match_status_code(http_response.status, ['404', '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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -23,11 +23,11 @@ module PlexRubySDK
|
||||
end
|
||||
|
||||
|
||||
sig { params(count: T.nilable(::Float), only_transient: T.nilable(::PlexRubySDK::Operations::OnlyTransient), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetGlobalHubsResponse) }
|
||||
sig { params(count: T.nilable(::Float), only_transient: T.nilable(Models::Operations::OnlyTransient), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetGlobalHubsResponse) }
|
||||
def get_global_hubs(count = nil, only_transient = nil, timeout_ms = nil)
|
||||
# get_global_hubs - Get Global Hubs
|
||||
# Get Global Hubs filtered by the parameters provided.
|
||||
request = ::PlexRubySDK::Operations::GetGlobalHubsRequest.new(
|
||||
request = Models::Operations::GetGlobalHubsRequest.new(
|
||||
|
||||
count: count,
|
||||
only_transient: only_transient
|
||||
@@ -36,7 +36,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/hubs"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetGlobalHubsRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::GetGlobalHubsRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -55,10 +55,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -74,56 +75,90 @@ 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 = 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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetGlobalHubsResponseBody)
|
||||
response = Models::Operations::GetGlobalHubsResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
object: obj
|
||||
)
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetGlobalHubsBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetGlobalHubsUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetGlobalHubsResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetGlobalHubsResponseBody)
|
||||
res.object = out
|
||||
end
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetGlobalHubsBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetGlobalHubsUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetRecentlyAddedRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetRecentlyAddedResponse) }
|
||||
sig { params(request: T.nilable(Models::Operations::GetRecentlyAddedRequest), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetRecentlyAddedResponse) }
|
||||
def get_recently_added(request, timeout_ms = nil)
|
||||
# get_recently_added - Get Recently Added
|
||||
# This endpoint will return the recently added content.
|
||||
@@ -132,7 +167,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/hubs/home/recentlyAdded"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetRecentlyAddedRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::GetRecentlyAddedRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -151,10 +186,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -170,52 +206,67 @@ 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::GetRecentlyAddedResponse.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::GetRecentlyAddedResponseBody)
|
||||
res.object = out
|
||||
end
|
||||
elsif [400, 401].include?(r.status)
|
||||
end
|
||||
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::GetRecentlyAddedResponseBody)
|
||||
response = Models::Operations::GetRecentlyAddedResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
object: obj
|
||||
)
|
||||
|
||||
res
|
||||
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 Utils.match_status_code(http_response.status, ['400', '401', '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'
|
||||
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
sig { params(section_id: ::Float, count: T.nilable(::Float), only_transient: T.nilable(::PlexRubySDK::Operations::QueryParamOnlyTransient), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetLibraryHubsResponse) }
|
||||
sig { params(section_id: ::Float, count: T.nilable(::Float), only_transient: T.nilable(Models::Operations::QueryParamOnlyTransient), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetLibraryHubsResponse) }
|
||||
def get_library_hubs(section_id, count = nil, only_transient = nil, timeout_ms = nil)
|
||||
# get_library_hubs - Get library specific hubs
|
||||
# This endpoint will return a list of library specific hubs
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::GetLibraryHubsRequest.new(
|
||||
request = Models::Operations::GetLibraryHubsRequest.new(
|
||||
|
||||
section_id: section_id,
|
||||
count: count,
|
||||
@@ -224,13 +275,13 @@ module PlexRubySDK
|
||||
url, params = @sdk_configuration.get_server_details
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = Utils.generate_url(
|
||||
::PlexRubySDK::Operations::GetLibraryHubsRequest,
|
||||
Models::Operations::GetLibraryHubsRequest,
|
||||
base_url,
|
||||
'/hubs/sections/{sectionId}',
|
||||
request
|
||||
)
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetLibraryHubsRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::GetLibraryHubsRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -249,10 +300,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -268,52 +320,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 = 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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetLibraryHubsResponseBody)
|
||||
response = Models::Operations::GetLibraryHubsResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
object: obj
|
||||
)
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetLibraryHubsBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetLibraryHubsUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetLibraryHubsResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryHubsResponseBody)
|
||||
res.object = out
|
||||
end
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryHubsBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetLibraryHubsUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -23,12 +23,12 @@ module PlexRubySDK
|
||||
end
|
||||
|
||||
|
||||
sig { params(level: ::PlexRubySDK::Operations::Level, message: ::String, source: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::LogLineResponse) }
|
||||
sig { params(level: Models::Operations::Level, message: ::String, source: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::LogLineResponse) }
|
||||
def log_line(level, message, source, timeout_ms = nil)
|
||||
# log_line - Logging a single line message.
|
||||
# This endpoint will write a single-line log message, including a level and source to the main Plex Media Server log.
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::LogLineRequest.new(
|
||||
request = Models::Operations::LogLineRequest.new(
|
||||
|
||||
level: level,
|
||||
message: message,
|
||||
@@ -38,7 +38,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/log"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::LogLineRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::LogLineRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -57,10 +57,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -76,52 +77,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::LogLineResponse.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::LogLineResponse.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::LogLineBadRequest)
|
||||
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::LogLineBadRequest)
|
||||
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::LogLineUnauthorized)
|
||||
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::LogLineUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(request: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::LogMultiLineResponse) }
|
||||
sig { params(request: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::LogMultiLineResponse) }
|
||||
def log_multi_line(request, timeout_ms = nil)
|
||||
# log_multi_line - Logging a multi-line message
|
||||
# This endpoint allows for the batch addition of log entries to the main Plex Media Server log.
|
||||
@@ -179,10 +210,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.post(url) do |req|
|
||||
http_response = connection.post(url) do |req|
|
||||
req.body = body
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
@@ -198,52 +230,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::LogMultiLineResponse.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::LogMultiLineResponse.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::LogMultiLineBadRequest)
|
||||
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::LogMultiLineBadRequest)
|
||||
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::LogMultiLineUnauthorized)
|
||||
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::LogMultiLineUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::EnablePaperTrailResponse) }
|
||||
sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::EnablePaperTrailResponse) }
|
||||
def enable_paper_trail(timeout_ms = nil)
|
||||
# enable_paper_trail - Enabling Papertrail
|
||||
# This endpoint will enable all Plex Media Serverlogs to be sent to the Papertrail networked logging site for a period of time.
|
||||
@@ -270,10 +332,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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?
|
||||
Utils.configure_request_security(req, security)
|
||||
@@ -288,49 +351,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::EnablePaperTrailResponse.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::EnablePaperTrailResponse.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::EnablePaperTrailBadRequest)
|
||||
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::EnablePaperTrailBadRequest)
|
||||
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::EnablePaperTrailUnauthorized)
|
||||
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::EnablePaperTrailUnauthorized)
|
||||
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 == 403
|
||||
elsif Utils.match_status_code(http_response.status, ['403', '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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -23,11 +23,11 @@ module PlexRubySDK
|
||||
end
|
||||
|
||||
|
||||
sig { params(key: ::Float, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::MarkPlayedResponse) }
|
||||
sig { params(key: ::Float, timeout_ms: T.nilable(Integer)).returns(Models::Operations::MarkPlayedResponse) }
|
||||
def mark_played(key, timeout_ms = nil)
|
||||
# mark_played - Mark Media Played
|
||||
# This will mark the provided media key as Played.
|
||||
request = ::PlexRubySDK::Operations::MarkPlayedRequest.new(
|
||||
request = Models::Operations::MarkPlayedRequest.new(
|
||||
|
||||
key: key
|
||||
)
|
||||
@@ -35,7 +35,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/:/scrobble"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::MarkPlayedRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::MarkPlayedRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -54,10 +54,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -73,56 +74,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::MarkPlayedResponse.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::MarkPlayedResponse.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::MarkPlayedBadRequest)
|
||||
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::MarkPlayedBadRequest)
|
||||
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::MarkPlayedUnauthorized)
|
||||
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::MarkPlayedUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(key: ::Float, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::MarkUnplayedResponse) }
|
||||
sig { params(key: ::Float, timeout_ms: T.nilable(Integer)).returns(Models::Operations::MarkUnplayedResponse) }
|
||||
def mark_unplayed(key, timeout_ms = nil)
|
||||
# mark_unplayed - Mark Media Unplayed
|
||||
# This will mark the provided media key as Unplayed.
|
||||
request = ::PlexRubySDK::Operations::MarkUnplayedRequest.new(
|
||||
request = Models::Operations::MarkUnplayedRequest.new(
|
||||
|
||||
key: key
|
||||
)
|
||||
@@ -130,7 +161,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/:/unscrobble"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::MarkUnplayedRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::MarkUnplayedRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -149,10 +180,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -168,57 +200,87 @@ 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::MarkUnplayedResponse.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::MarkUnplayedResponse.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::MarkUnplayedBadRequest)
|
||||
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::MarkUnplayedBadRequest)
|
||||
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::MarkUnplayedUnauthorized)
|
||||
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::MarkUnplayedUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(key: ::String, time: ::Float, state: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::UpdatePlayProgressResponse) }
|
||||
sig { params(key: ::String, time: ::Float, state: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::UpdatePlayProgressResponse) }
|
||||
def update_play_progress(key, time, state, timeout_ms = nil)
|
||||
# update_play_progress - Update Media Play Progress
|
||||
# This API command can be used to update the play progress of a media item.
|
||||
#
|
||||
request = ::PlexRubySDK::Operations::UpdatePlayProgressRequest.new(
|
||||
request = Models::Operations::UpdatePlayProgressRequest.new(
|
||||
|
||||
key: key,
|
||||
time: time,
|
||||
@@ -228,7 +290,7 @@ module PlexRubySDK
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = "#{base_url}/:/progress"
|
||||
headers = {}
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::UpdatePlayProgressRequest, request)
|
||||
query_params = Utils.get_query_params(Models::Operations::UpdatePlayProgressRequest, request)
|
||||
headers['Accept'] = 'application/json'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
@@ -247,10 +309,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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.post(url) do |req|
|
||||
http_response = connection.post(url) do |req|
|
||||
req.headers.merge!(headers)
|
||||
req.options.timeout = timeout unless timeout.nil?
|
||||
req.params = query_params
|
||||
@@ -266,66 +329,96 @@ 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::UpdatePlayProgressResponse.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::UpdatePlayProgressResponse.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::UpdatePlayProgressBadRequest)
|
||||
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::UpdatePlayProgressBadRequest)
|
||||
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::UpdatePlayProgressUnauthorized)
|
||||
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::UpdatePlayProgressUnauthorized)
|
||||
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 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'
|
||||
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetBannerImageRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetBannerImageResponse) }
|
||||
sig { params(request: T.nilable(Models::Operations::GetBannerImageRequest), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetBannerImageResponse) }
|
||||
def get_banner_image(request, timeout_ms = nil)
|
||||
# get_banner_image - Get Banner Image
|
||||
# Gets the banner image of the media item
|
||||
url, params = @sdk_configuration.get_server_details
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = Utils.generate_url(
|
||||
::PlexRubySDK::Operations::GetBannerImageRequest,
|
||||
Models::Operations::GetBannerImageRequest,
|
||||
base_url,
|
||||
'/library/metadata/{ratingKey}/banner',
|
||||
request
|
||||
)
|
||||
headers = Utils.get_headers(request)
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetBannerImageRequest, request)
|
||||
headers['Accept'] = 'application/json;q=1, image/jpeg;q=0'
|
||||
query_params = Utils.get_query_params(Models::Operations::GetBannerImageRequest, request)
|
||||
headers['Accept'] = 'image/jpeg'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
||||
@@ -343,10 +436,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -362,68 +456,104 @@ 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 = 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, 'image/jpeg')
|
||||
http_response = @sdk_configuration.hooks.after_success(
|
||||
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
||||
hook_ctx: hook_ctx
|
||||
),
|
||||
response: http_response
|
||||
)
|
||||
obj = http_response.env.body
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
return Models::Operations::GetBannerImageResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
headers: http_response.get_headers,
|
||||
bytes: 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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetBannerImageBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetBannerImageUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetBannerImageResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
res.headers = r.headers
|
||||
res.bytes = r.env.response_body if Utils.match_content_type(content_type, 'image/jpeg')
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetBannerImageBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetBannerImageUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
|
||||
|
||||
sig { params(request: T.nilable(::PlexRubySDK::Operations::GetThumbImageRequest), timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetThumbImageResponse) }
|
||||
sig { params(request: T.nilable(Models::Operations::GetThumbImageRequest), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetThumbImageResponse) }
|
||||
def get_thumb_image(request, timeout_ms = nil)
|
||||
# get_thumb_image - Get Thumb Image
|
||||
# Gets the thumbnail image of the media item
|
||||
url, params = @sdk_configuration.get_server_details
|
||||
base_url = Utils.template_url(url, params)
|
||||
url = Utils.generate_url(
|
||||
::PlexRubySDK::Operations::GetThumbImageRequest,
|
||||
Models::Operations::GetThumbImageRequest,
|
||||
base_url,
|
||||
'/library/metadata/{ratingKey}/thumb',
|
||||
request
|
||||
)
|
||||
headers = Utils.get_headers(request)
|
||||
query_params = Utils.get_query_params(::PlexRubySDK::Operations::GetThumbImageRequest, request)
|
||||
headers['Accept'] = 'application/json;q=1, image/jpeg;q=0'
|
||||
query_params = Utils.get_query_params(Models::Operations::GetThumbImageRequest, request)
|
||||
headers['Accept'] = 'image/jpeg'
|
||||
headers['user-agent'] = @sdk_configuration.user_agent
|
||||
|
||||
security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
|
||||
@@ -441,10 +571,11 @@ module PlexRubySDK
|
||||
)
|
||||
|
||||
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
|
||||
@@ -460,50 +591,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 = 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, 'image/jpeg')
|
||||
http_response = @sdk_configuration.hooks.after_success(
|
||||
hook_ctx: SDKHooks::AfterSuccessHookContext.new(
|
||||
hook_ctx: hook_ctx
|
||||
),
|
||||
response: http_response
|
||||
)
|
||||
obj = http_response.env.body
|
||||
|
||||
content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
|
||||
return Models::Operations::GetThumbImageResponse.new(
|
||||
status_code: http_response.status,
|
||||
content_type: content_type,
|
||||
raw_response: http_response,
|
||||
headers: http_response.get_headers,
|
||||
bytes: 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 Utils.match_status_code(http_response.status, ['400'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetThumbImageBadRequest)
|
||||
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 Utils.match_status_code(http_response.status, ['401'])
|
||||
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
|
||||
)
|
||||
obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetThumbImageUnauthorized)
|
||||
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 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 = ::PlexRubySDK::Operations::GetThumbImageResponse.new(
|
||||
status_code: r.status, content_type: content_type, raw_response: r
|
||||
)
|
||||
if r.status == 200
|
||||
res.headers = r.headers
|
||||
res.bytes = r.env.response_body if Utils.match_content_type(content_type, 'image/jpeg')
|
||||
elsif r.status == 400
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetThumbImageBadRequest)
|
||||
res.bad_request = out
|
||||
end
|
||||
elsif r.status == 401
|
||||
if Utils.match_content_type(content_type, 'application/json')
|
||||
out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetThumbImageUnauthorized)
|
||||
res.unauthorized = out
|
||||
end
|
||||
end
|
||||
|
||||
res
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
323
lib/plex_ruby_sdk/models/errors.rb
Normal file
323
lib/plex_ruby_sdk/models/errors.rb
Normal file
@@ -0,0 +1,323 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
autoload :APIError, 'plex_ruby_sdk/models/errors/apierror.rb'
|
||||
autoload :AddPlaylistContentsBadRequest, 'plex_ruby_sdk/models/errors/addplaylistcontents_badrequest.rb'
|
||||
autoload :AddPlaylistContentsPlaylistsErrors, 'plex_ruby_sdk/models/errors/addplaylistcontents_playlists_errors.rb'
|
||||
autoload :AddPlaylistContentsUnauthorized, 'plex_ruby_sdk/models/errors/addplaylistcontents_unauthorized.rb'
|
||||
autoload :AddPlaylistContentsErrors, 'plex_ruby_sdk/models/errors/addplaylistcontents_errors.rb'
|
||||
autoload :ApplyUpdatesBadRequest, 'plex_ruby_sdk/models/errors/applyupdates_badrequest.rb'
|
||||
autoload :ApplyUpdatesUnauthorized, 'plex_ruby_sdk/models/errors/applyupdates_unauthorized.rb'
|
||||
autoload :ApplyUpdatesUpdaterErrors, 'plex_ruby_sdk/models/errors/applyupdates_updater_errors.rb'
|
||||
autoload :ApplyUpdatesErrors, 'plex_ruby_sdk/models/errors/applyupdates_errors.rb'
|
||||
autoload :CancelServerActivitiesActivitiesErrors, 'plex_ruby_sdk/models/errors/cancelserveractivities_activities_errors.rb'
|
||||
autoload :CancelServerActivitiesBadRequest, 'plex_ruby_sdk/models/errors/cancelserveractivities_badrequest.rb'
|
||||
autoload :CancelServerActivitiesUnauthorized, 'plex_ruby_sdk/models/errors/cancelserveractivities_unauthorized.rb'
|
||||
autoload :CancelServerActivitiesErrors, 'plex_ruby_sdk/models/errors/cancelserveractivities_errors.rb'
|
||||
autoload :CheckForUpdatesBadRequest, 'plex_ruby_sdk/models/errors/checkforupdates_badrequest.rb'
|
||||
autoload :CheckForUpdatesUnauthorized, 'plex_ruby_sdk/models/errors/checkforupdates_unauthorized.rb'
|
||||
autoload :CheckForUpdatesUpdaterErrors, 'plex_ruby_sdk/models/errors/checkforupdates_updater_errors.rb'
|
||||
autoload :CheckForUpdatesErrors, 'plex_ruby_sdk/models/errors/checkforupdates_errors.rb'
|
||||
autoload :ClearPlaylistContentsBadRequest, 'plex_ruby_sdk/models/errors/clearplaylistcontents_badrequest.rb'
|
||||
autoload :ClearPlaylistContentsPlaylistsErrors, 'plex_ruby_sdk/models/errors/clearplaylistcontents_playlists_errors.rb'
|
||||
autoload :ClearPlaylistContentsUnauthorized, 'plex_ruby_sdk/models/errors/clearplaylistcontents_unauthorized.rb'
|
||||
autoload :ClearPlaylistContentsErrors, 'plex_ruby_sdk/models/errors/clearplaylistcontents_errors.rb'
|
||||
autoload :CreatePlaylistBadRequest, 'plex_ruby_sdk/models/errors/createplaylist_badrequest.rb'
|
||||
autoload :CreatePlaylistPlaylistsErrors, 'plex_ruby_sdk/models/errors/createplaylist_playlists_errors.rb'
|
||||
autoload :CreatePlaylistUnauthorized, 'plex_ruby_sdk/models/errors/createplaylist_unauthorized.rb'
|
||||
autoload :CreatePlaylistErrors, 'plex_ruby_sdk/models/errors/createplaylist_errors.rb'
|
||||
autoload :DeleteLibraryBadRequest, 'plex_ruby_sdk/models/errors/deletelibrary_badrequest.rb'
|
||||
autoload :DeleteLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/deletelibrary_library_errors.rb'
|
||||
autoload :DeleteLibraryUnauthorized, 'plex_ruby_sdk/models/errors/deletelibrary_unauthorized.rb'
|
||||
autoload :DeleteLibraryErrors, 'plex_ruby_sdk/models/errors/deletelibrary_errors.rb'
|
||||
autoload :DeletePlaylistBadRequest, 'plex_ruby_sdk/models/errors/deleteplaylist_badrequest.rb'
|
||||
autoload :DeletePlaylistPlaylistsErrors, 'plex_ruby_sdk/models/errors/deleteplaylist_playlists_errors.rb'
|
||||
autoload :DeletePlaylistUnauthorized, 'plex_ruby_sdk/models/errors/deleteplaylist_unauthorized.rb'
|
||||
autoload :DeletePlaylistErrors, 'plex_ruby_sdk/models/errors/deleteplaylist_errors.rb'
|
||||
autoload :EnablePaperTrailBadRequest, 'plex_ruby_sdk/models/errors/enablepapertrail_badrequest.rb'
|
||||
autoload :EnablePaperTrailLogErrors, 'plex_ruby_sdk/models/errors/enablepapertrail_log_errors.rb'
|
||||
autoload :EnablePaperTrailUnauthorized, 'plex_ruby_sdk/models/errors/enablepapertrail_unauthorized.rb'
|
||||
autoload :EnablePaperTrailErrors, 'plex_ruby_sdk/models/errors/enablepapertrail_errors.rb'
|
||||
autoload :Errors, 'plex_ruby_sdk/models/errors/errors.rb'
|
||||
autoload :GetActorsLibraryBadRequest, 'plex_ruby_sdk/models/errors/get_actors_library_badrequest.rb'
|
||||
autoload :GetActorsLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/get_actors_library_library_errors.rb'
|
||||
autoload :GetActorsLibraryUnauthorized, 'plex_ruby_sdk/models/errors/get_actors_library_unauthorized.rb'
|
||||
autoload :GetActorsLibraryErrors, 'plex_ruby_sdk/models/errors/get_actors_library_errors.rb'
|
||||
autoload :GetAllLibrariesBadRequest, 'plex_ruby_sdk/models/errors/get_all_libraries_badrequest.rb'
|
||||
autoload :GetAllLibrariesLibraryErrors, 'plex_ruby_sdk/models/errors/get_all_libraries_library_errors.rb'
|
||||
autoload :GetAllLibrariesUnauthorized, 'plex_ruby_sdk/models/errors/get_all_libraries_unauthorized.rb'
|
||||
autoload :GetAllLibrariesErrors, 'plex_ruby_sdk/models/errors/get_all_libraries_errors.rb'
|
||||
autoload :GetAllMediaLibraryBadRequest, 'plex_ruby_sdk/models/errors/get_all_media_library_badrequest.rb'
|
||||
autoload :GetAllMediaLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/get_all_media_library_library_errors.rb'
|
||||
autoload :GetAllMediaLibraryUnauthorized, 'plex_ruby_sdk/models/errors/get_all_media_library_unauthorized.rb'
|
||||
autoload :GetAllMediaLibraryErrors, 'plex_ruby_sdk/models/errors/get_all_media_library_errors.rb'
|
||||
autoload :GetBannerImageBadRequest, 'plex_ruby_sdk/models/errors/get_banner_image_badrequest.rb'
|
||||
autoload :GetBannerImageMediaErrors, 'plex_ruby_sdk/models/errors/get_banner_image_media_errors.rb'
|
||||
autoload :GetBannerImageUnauthorized, 'plex_ruby_sdk/models/errors/get_banner_image_unauthorized.rb'
|
||||
autoload :GetBannerImageErrors, 'plex_ruby_sdk/models/errors/get_banner_image_errors.rb'
|
||||
autoload :GetCountriesLibraryBadRequest, 'plex_ruby_sdk/models/errors/get_countries_library_badrequest.rb'
|
||||
autoload :GetCountriesLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/get_countries_library_library_errors.rb'
|
||||
autoload :GetCountriesLibraryUnauthorized, 'plex_ruby_sdk/models/errors/get_countries_library_unauthorized.rb'
|
||||
autoload :GetCountriesLibraryErrors, 'plex_ruby_sdk/models/errors/get_countries_library_errors.rb'
|
||||
autoload :GetGenresLibraryBadRequest, 'plex_ruby_sdk/models/errors/get_genres_library_badrequest.rb'
|
||||
autoload :GetGenresLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/get_genres_library_library_errors.rb'
|
||||
autoload :GetGenresLibraryUnauthorized, 'plex_ruby_sdk/models/errors/get_genres_library_unauthorized.rb'
|
||||
autoload :GetGenresLibraryErrors, 'plex_ruby_sdk/models/errors/get_genres_library_errors.rb'
|
||||
autoload :GetLibraryDetailsBadRequest, 'plex_ruby_sdk/models/errors/get_library_details_badrequest.rb'
|
||||
autoload :GetLibraryDetailsLibraryErrors, 'plex_ruby_sdk/models/errors/get_library_details_library_errors.rb'
|
||||
autoload :GetLibraryDetailsUnauthorized, 'plex_ruby_sdk/models/errors/get_library_details_unauthorized.rb'
|
||||
autoload :GetLibraryDetailsErrors, 'plex_ruby_sdk/models/errors/get_library_details_errors.rb'
|
||||
autoload :GetLibraryItemsBadRequest, 'plex_ruby_sdk/models/errors/get_library_items_badrequest.rb'
|
||||
autoload :GetLibraryItemsLibraryErrors, 'plex_ruby_sdk/models/errors/get_library_items_library_errors.rb'
|
||||
autoload :GetLibraryItemsUnauthorized, 'plex_ruby_sdk/models/errors/get_library_items_unauthorized.rb'
|
||||
autoload :GetLibraryItemsErrors, 'plex_ruby_sdk/models/errors/get_library_items_errors.rb'
|
||||
autoload :GetMediaMetaDataBadRequest, 'plex_ruby_sdk/models/errors/get_media_meta_data_badrequest.rb'
|
||||
autoload :GetMediaMetaDataLibraryErrors, 'plex_ruby_sdk/models/errors/get_media_meta_data_library_errors.rb'
|
||||
autoload :GetMediaMetaDataUnauthorized, 'plex_ruby_sdk/models/errors/get_media_meta_data_unauthorized.rb'
|
||||
autoload :GetMediaMetaDataErrors, 'plex_ruby_sdk/models/errors/get_media_meta_data_errors.rb'
|
||||
autoload :GetMediaProvidersBadRequest, 'plex_ruby_sdk/models/errors/get_media_providers_badrequest.rb'
|
||||
autoload :GetMediaProvidersServerErrors, 'plex_ruby_sdk/models/errors/get_media_providers_server_errors.rb'
|
||||
autoload :GetMediaProvidersUnauthorized, 'plex_ruby_sdk/models/errors/get_media_providers_unauthorized.rb'
|
||||
autoload :GetMediaProvidersErrors, 'plex_ruby_sdk/models/errors/get_media_providers_errors.rb'
|
||||
autoload :GetRecentlyAddedLibraryBadRequest, 'plex_ruby_sdk/models/errors/get_recently_added_library_badrequest.rb'
|
||||
autoload :GetRecentlyAddedLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/get_recently_added_library_library_errors.rb'
|
||||
autoload :GetRecentlyAddedLibraryUnauthorized, 'plex_ruby_sdk/models/errors/get_recently_added_library_unauthorized.rb'
|
||||
autoload :GetRecentlyAddedLibraryErrors, 'plex_ruby_sdk/models/errors/get_recently_added_library_errors.rb'
|
||||
autoload :GetRefreshLibraryMetadataBadRequest, 'plex_ruby_sdk/models/errors/get_refresh_library_metadata_badrequest.rb'
|
||||
autoload :GetRefreshLibraryMetadataLibraryErrors, 'plex_ruby_sdk/models/errors/get_refresh_library_metadata_library_errors.rb'
|
||||
autoload :GetRefreshLibraryMetadataUnauthorized, 'plex_ruby_sdk/models/errors/get_refresh_library_metadata_unauthorized.rb'
|
||||
autoload :GetRefreshLibraryMetadataErrors, 'plex_ruby_sdk/models/errors/get_refresh_library_metadata_errors.rb'
|
||||
autoload :GetSearchAllLibrariesBadRequest, 'plex_ruby_sdk/models/errors/get_search_all_libraries_badrequest.rb'
|
||||
autoload :GetSearchAllLibrariesLibraryErrors, 'plex_ruby_sdk/models/errors/get_search_all_libraries_library_errors.rb'
|
||||
autoload :GetSearchAllLibrariesUnauthorized, 'plex_ruby_sdk/models/errors/get_search_all_libraries_unauthorized.rb'
|
||||
autoload :GetSearchAllLibrariesErrors, 'plex_ruby_sdk/models/errors/get_search_all_libraries_errors.rb'
|
||||
autoload :GetSearchLibraryBadRequest, 'plex_ruby_sdk/models/errors/get_search_library_badrequest.rb'
|
||||
autoload :GetSearchLibraryLibraryErrors, 'plex_ruby_sdk/models/errors/get_search_library_library_errors.rb'
|
||||
autoload :GetSearchLibraryUnauthorized, 'plex_ruby_sdk/models/errors/get_search_library_unauthorized.rb'
|
||||
autoload :GetSearchLibraryErrors, 'plex_ruby_sdk/models/errors/get_search_library_errors.rb'
|
||||
autoload :GetServerIdentityRequestTimeout, 'plex_ruby_sdk/models/errors/get_server_identity_requesttimeout.rb'
|
||||
autoload :GetServerResourcesBadRequest, 'plex_ruby_sdk/models/errors/get_server_resources_badrequest.rb'
|
||||
autoload :GetServerResourcesPlexErrors, 'plex_ruby_sdk/models/errors/get_server_resources_plex_errors.rb'
|
||||
autoload :GetServerResourcesUnauthorized, 'plex_ruby_sdk/models/errors/get_server_resources_unauthorized.rb'
|
||||
autoload :GetServerResourcesErrors, 'plex_ruby_sdk/models/errors/get_server_resources_errors.rb'
|
||||
autoload :GetThumbImageBadRequest, 'plex_ruby_sdk/models/errors/get_thumb_image_badrequest.rb'
|
||||
autoload :GetThumbImageMediaErrors, 'plex_ruby_sdk/models/errors/get_thumb_image_media_errors.rb'
|
||||
autoload :GetThumbImageUnauthorized, 'plex_ruby_sdk/models/errors/get_thumb_image_unauthorized.rb'
|
||||
autoload :GetThumbImageErrors, 'plex_ruby_sdk/models/errors/get_thumb_image_errors.rb'
|
||||
autoload :GetUsersBadRequest, 'plex_ruby_sdk/models/errors/get_users_badrequest.rb'
|
||||
autoload :GetUsersUnauthorized, 'plex_ruby_sdk/models/errors/get_users_unauthorized.rb'
|
||||
autoload :GetUsersUsersErrors, 'plex_ruby_sdk/models/errors/get_users_users_errors.rb'
|
||||
autoload :GetUsersErrors, 'plex_ruby_sdk/models/errors/get_users_errors.rb'
|
||||
autoload :GetWatchListBadRequest, 'plex_ruby_sdk/models/errors/get_watch_list_badrequest.rb'
|
||||
autoload :GetWatchListUnauthorized, 'plex_ruby_sdk/models/errors/get_watch_list_unauthorized.rb'
|
||||
autoload :GetWatchListWatchlistErrors, 'plex_ruby_sdk/models/errors/get_watch_list_watchlist_errors.rb'
|
||||
autoload :GetWatchListErrors, 'plex_ruby_sdk/models/errors/get_watch_list_errors.rb'
|
||||
autoload :GetAvailableClientsBadRequest, 'plex_ruby_sdk/models/errors/getavailableclients_badrequest.rb'
|
||||
autoload :GetAvailableClientsServerErrors, 'plex_ruby_sdk/models/errors/getavailableclients_server_errors.rb'
|
||||
autoload :GetAvailableClientsUnauthorized, 'plex_ruby_sdk/models/errors/getavailableclients_unauthorized.rb'
|
||||
autoload :GetAvailableClientsErrors, 'plex_ruby_sdk/models/errors/getavailableclients_errors.rb'
|
||||
autoload :GetBandwidthStatisticsBadRequest, 'plex_ruby_sdk/models/errors/getbandwidthstatistics_badrequest.rb'
|
||||
autoload :GetBandwidthStatisticsStatisticsErrors, 'plex_ruby_sdk/models/errors/getbandwidthstatistics_statistics_errors.rb'
|
||||
autoload :GetBandwidthStatisticsUnauthorized, 'plex_ruby_sdk/models/errors/getbandwidthstatistics_unauthorized.rb'
|
||||
autoload :GetBandwidthStatisticsErrors, 'plex_ruby_sdk/models/errors/getbandwidthstatistics_errors.rb'
|
||||
autoload :GetButlerTasksBadRequest, 'plex_ruby_sdk/models/errors/getbutlertasks_badrequest.rb'
|
||||
autoload :GetButlerTasksButlerErrors, 'plex_ruby_sdk/models/errors/getbutlertasks_butler_errors.rb'
|
||||
autoload :GetButlerTasksUnauthorized, 'plex_ruby_sdk/models/errors/getbutlertasks_unauthorized.rb'
|
||||
autoload :GetButlerTasksErrors, 'plex_ruby_sdk/models/errors/getbutlertasks_errors.rb'
|
||||
autoload :GetCompanionsDataBadRequest, 'plex_ruby_sdk/models/errors/getcompanionsdata_badrequest.rb'
|
||||
autoload :GetCompanionsDataPlexErrors, 'plex_ruby_sdk/models/errors/getcompanionsdata_plex_errors.rb'
|
||||
autoload :GetCompanionsDataUnauthorized, 'plex_ruby_sdk/models/errors/getcompanionsdata_unauthorized.rb'
|
||||
autoload :GetCompanionsDataErrors, 'plex_ruby_sdk/models/errors/getcompanionsdata_errors.rb'
|
||||
autoload :GetDevicesBadRequest, 'plex_ruby_sdk/models/errors/getdevices_badrequest.rb'
|
||||
autoload :GetDevicesServerErrors, 'plex_ruby_sdk/models/errors/getdevices_server_errors.rb'
|
||||
autoload :GetDevicesUnauthorized, 'plex_ruby_sdk/models/errors/getdevices_unauthorized.rb'
|
||||
autoload :GetDevicesErrors, 'plex_ruby_sdk/models/errors/getdevices_errors.rb'
|
||||
autoload :GetFileHashBadRequest, 'plex_ruby_sdk/models/errors/getfilehash_badrequest.rb'
|
||||
autoload :GetFileHashLibraryErrors, 'plex_ruby_sdk/models/errors/getfilehash_library_errors.rb'
|
||||
autoload :GetFileHashUnauthorized, 'plex_ruby_sdk/models/errors/getfilehash_unauthorized.rb'
|
||||
autoload :GetFileHashErrors, 'plex_ruby_sdk/models/errors/getfilehash_errors.rb'
|
||||
autoload :GetGeoDataBadRequest, 'plex_ruby_sdk/models/errors/getgeodata_badrequest.rb'
|
||||
autoload :GetGeoDataPlexErrors, 'plex_ruby_sdk/models/errors/getgeodata_plex_errors.rb'
|
||||
autoload :GetGeoDataUnauthorized, 'plex_ruby_sdk/models/errors/getgeodata_unauthorized.rb'
|
||||
autoload :GetGeoDataErrors, 'plex_ruby_sdk/models/errors/getgeodata_errors.rb'
|
||||
autoload :GetGlobalHubsBadRequest, 'plex_ruby_sdk/models/errors/getglobalhubs_badrequest.rb'
|
||||
autoload :GetGlobalHubsHubsErrors, 'plex_ruby_sdk/models/errors/getglobalhubs_hubs_errors.rb'
|
||||
autoload :GetGlobalHubsUnauthorized, 'plex_ruby_sdk/models/errors/getglobalhubs_unauthorized.rb'
|
||||
autoload :GetGlobalHubsErrors, 'plex_ruby_sdk/models/errors/getglobalhubs_errors.rb'
|
||||
autoload :GetHomeDataBadRequest, 'plex_ruby_sdk/models/errors/gethomedata_badrequest.rb'
|
||||
autoload :GetHomeDataPlexErrors, 'plex_ruby_sdk/models/errors/gethomedata_plex_errors.rb'
|
||||
autoload :GetHomeDataUnauthorized, 'plex_ruby_sdk/models/errors/gethomedata_unauthorized.rb'
|
||||
autoload :GetHomeDataErrors, 'plex_ruby_sdk/models/errors/gethomedata_errors.rb'
|
||||
autoload :GetLibraryHubsBadRequest, 'plex_ruby_sdk/models/errors/getlibraryhubs_badrequest.rb'
|
||||
autoload :GetLibraryHubsHubsErrors, 'plex_ruby_sdk/models/errors/getlibraryhubs_hubs_errors.rb'
|
||||
autoload :GetLibraryHubsUnauthorized, 'plex_ruby_sdk/models/errors/getlibraryhubs_unauthorized.rb'
|
||||
autoload :GetLibraryHubsErrors, 'plex_ruby_sdk/models/errors/getlibraryhubs_errors.rb'
|
||||
autoload :GetMetadataChildrenBadRequest, 'plex_ruby_sdk/models/errors/getmetadatachildren_badrequest.rb'
|
||||
autoload :GetMetadataChildrenLibraryErrors, 'plex_ruby_sdk/models/errors/getmetadatachildren_library_errors.rb'
|
||||
autoload :GetMetadataChildrenUnauthorized, 'plex_ruby_sdk/models/errors/getmetadatachildren_unauthorized.rb'
|
||||
autoload :GetMetadataChildrenErrors, 'plex_ruby_sdk/models/errors/getmetadatachildren_errors.rb'
|
||||
autoload :GetMyPlexAccountBadRequest, 'plex_ruby_sdk/models/errors/getmyplexaccount_badrequest.rb'
|
||||
autoload :GetMyPlexAccountServerErrors, 'plex_ruby_sdk/models/errors/getmyplexaccount_server_errors.rb'
|
||||
autoload :GetMyPlexAccountUnauthorized, 'plex_ruby_sdk/models/errors/getmyplexaccount_unauthorized.rb'
|
||||
autoload :GetMyPlexAccountErrors, 'plex_ruby_sdk/models/errors/getmyplexaccount_errors.rb'
|
||||
autoload :GetPinBadRequest, 'plex_ruby_sdk/models/errors/getpin_badrequest.rb'
|
||||
autoload :GetPinErrors, 'plex_ruby_sdk/models/errors/getpin_errors.rb'
|
||||
autoload :GetPlaylistContentsBadRequest, 'plex_ruby_sdk/models/errors/getplaylistcontents_badrequest.rb'
|
||||
autoload :GetPlaylistContentsPlaylistsErrors, 'plex_ruby_sdk/models/errors/getplaylistcontents_playlists_errors.rb'
|
||||
autoload :GetPlaylistContentsUnauthorized, 'plex_ruby_sdk/models/errors/getplaylistcontents_unauthorized.rb'
|
||||
autoload :GetPlaylistContentsErrors, 'plex_ruby_sdk/models/errors/getplaylistcontents_errors.rb'
|
||||
autoload :GetPlaylistBadRequest, 'plex_ruby_sdk/models/errors/getplaylist_badrequest.rb'
|
||||
autoload :GetPlaylistPlaylistsErrors, 'plex_ruby_sdk/models/errors/getplaylist_playlists_errors.rb'
|
||||
autoload :GetPlaylistUnauthorized, 'plex_ruby_sdk/models/errors/getplaylist_unauthorized.rb'
|
||||
autoload :GetPlaylistErrors, 'plex_ruby_sdk/models/errors/getplaylist_errors.rb'
|
||||
autoload :GetPlaylistsBadRequest, 'plex_ruby_sdk/models/errors/getplaylists_badrequest.rb'
|
||||
autoload :GetPlaylistsPlaylistsErrors, 'plex_ruby_sdk/models/errors/getplaylists_playlists_errors.rb'
|
||||
autoload :GetPlaylistsUnauthorized, 'plex_ruby_sdk/models/errors/getplaylists_unauthorized.rb'
|
||||
autoload :GetPlaylistsErrors, 'plex_ruby_sdk/models/errors/getplaylists_errors.rb'
|
||||
autoload :GetResizedPhotoBadRequest, 'plex_ruby_sdk/models/errors/getresizedphoto_badrequest.rb'
|
||||
autoload :GetResizedPhotoServerErrors, 'plex_ruby_sdk/models/errors/getresizedphoto_server_errors.rb'
|
||||
autoload :GetResizedPhotoUnauthorized, 'plex_ruby_sdk/models/errors/getresizedphoto_unauthorized.rb'
|
||||
autoload :GetResizedPhotoErrors, 'plex_ruby_sdk/models/errors/getresizedphoto_errors.rb'
|
||||
autoload :GetResourcesStatisticsBadRequest, 'plex_ruby_sdk/models/errors/getresourcesstatistics_badrequest.rb'
|
||||
autoload :GetResourcesStatisticsStatisticsErrors, 'plex_ruby_sdk/models/errors/getresourcesstatistics_statistics_errors.rb'
|
||||
autoload :GetResourcesStatisticsUnauthorized, 'plex_ruby_sdk/models/errors/getresourcesstatistics_unauthorized.rb'
|
||||
autoload :GetResourcesStatisticsErrors, 'plex_ruby_sdk/models/errors/getresourcesstatistics_errors.rb'
|
||||
autoload :GetSearchResultsBadRequest, 'plex_ruby_sdk/models/errors/getsearchresults_badrequest.rb'
|
||||
autoload :GetSearchResultsSearchErrors, 'plex_ruby_sdk/models/errors/getsearchresults_search_errors.rb'
|
||||
autoload :GetSearchResultsUnauthorized, 'plex_ruby_sdk/models/errors/getsearchresults_unauthorized.rb'
|
||||
autoload :GetSearchResultsErrors, 'plex_ruby_sdk/models/errors/getsearchresults_errors.rb'
|
||||
autoload :GetServerActivitiesActivitiesErrors, 'plex_ruby_sdk/models/errors/getserveractivities_activities_errors.rb'
|
||||
autoload :GetServerActivitiesBadRequest, 'plex_ruby_sdk/models/errors/getserveractivities_badrequest.rb'
|
||||
autoload :GetServerActivitiesUnauthorized, 'plex_ruby_sdk/models/errors/getserveractivities_unauthorized.rb'
|
||||
autoload :GetServerActivitiesErrors, 'plex_ruby_sdk/models/errors/getserveractivities_errors.rb'
|
||||
autoload :GetServerCapabilitiesBadRequest, 'plex_ruby_sdk/models/errors/getservercapabilities_badrequest.rb'
|
||||
autoload :GetServerCapabilitiesUnauthorized, 'plex_ruby_sdk/models/errors/getservercapabilities_unauthorized.rb'
|
||||
autoload :GetServerCapabilitiesErrors, 'plex_ruby_sdk/models/errors/getservercapabilities_errors.rb'
|
||||
autoload :GetServerListBadRequest, 'plex_ruby_sdk/models/errors/getserverlist_badrequest.rb'
|
||||
autoload :GetServerListServerErrors, 'plex_ruby_sdk/models/errors/getserverlist_server_errors.rb'
|
||||
autoload :GetServerListUnauthorized, 'plex_ruby_sdk/models/errors/getserverlist_unauthorized.rb'
|
||||
autoload :GetServerListErrors, 'plex_ruby_sdk/models/errors/getserverlist_errors.rb'
|
||||
autoload :GetServerPreferencesBadRequest, 'plex_ruby_sdk/models/errors/getserverpreferences_badrequest.rb'
|
||||
autoload :GetServerPreferencesServerErrors, 'plex_ruby_sdk/models/errors/getserverpreferences_server_errors.rb'
|
||||
autoload :GetServerPreferencesUnauthorized, 'plex_ruby_sdk/models/errors/getserverpreferences_unauthorized.rb'
|
||||
autoload :GetServerPreferencesErrors, 'plex_ruby_sdk/models/errors/getserverpreferences_errors.rb'
|
||||
autoload :GetSessionHistoryBadRequest, 'plex_ruby_sdk/models/errors/getsessionhistory_badrequest.rb'
|
||||
autoload :GetSessionHistorySessionsErrors, 'plex_ruby_sdk/models/errors/getsessionhistory_sessions_errors.rb'
|
||||
autoload :GetSessionHistoryUnauthorized, 'plex_ruby_sdk/models/errors/getsessionhistory_unauthorized.rb'
|
||||
autoload :GetSessionHistoryErrors, 'plex_ruby_sdk/models/errors/getsessionhistory_errors.rb'
|
||||
autoload :GetSessionsBadRequest, 'plex_ruby_sdk/models/errors/getsessions_badrequest.rb'
|
||||
autoload :GetSessionsSessionsErrors, 'plex_ruby_sdk/models/errors/getsessions_sessions_errors.rb'
|
||||
autoload :GetSessionsUnauthorized, 'plex_ruby_sdk/models/errors/getsessions_unauthorized.rb'
|
||||
autoload :GetSessionsErrors, 'plex_ruby_sdk/models/errors/getsessions_errors.rb'
|
||||
autoload :GetSourceConnectionInformationAuthenticationErrors, 'plex_ruby_sdk/models/errors/getsourceconnectioninformation_authentication_errors.rb'
|
||||
autoload :GetSourceConnectionInformationBadRequest, 'plex_ruby_sdk/models/errors/getsourceconnectioninformation_badrequest.rb'
|
||||
autoload :GetSourceConnectionInformationUnauthorized, 'plex_ruby_sdk/models/errors/getsourceconnectioninformation_unauthorized.rb'
|
||||
autoload :GetSourceConnectionInformationErrors, 'plex_ruby_sdk/models/errors/getsourceconnectioninformation_errors.rb'
|
||||
autoload :GetStatisticsBadRequest, 'plex_ruby_sdk/models/errors/getstatistics_badrequest.rb'
|
||||
autoload :GetStatisticsStatisticsErrors, 'plex_ruby_sdk/models/errors/getstatistics_statistics_errors.rb'
|
||||
autoload :GetStatisticsUnauthorized, 'plex_ruby_sdk/models/errors/getstatistics_unauthorized.rb'
|
||||
autoload :GetStatisticsErrors, 'plex_ruby_sdk/models/errors/getstatistics_errors.rb'
|
||||
autoload :GetTimelineBadRequest, 'plex_ruby_sdk/models/errors/gettimeline_badrequest.rb'
|
||||
autoload :GetTimelineUnauthorized, 'plex_ruby_sdk/models/errors/gettimeline_unauthorized.rb'
|
||||
autoload :GetTimelineVideoErrors, 'plex_ruby_sdk/models/errors/gettimeline_video_errors.rb'
|
||||
autoload :GetTimelineErrors, 'plex_ruby_sdk/models/errors/gettimeline_errors.rb'
|
||||
autoload :GetTokenByPinIdBadRequest, 'plex_ruby_sdk/models/errors/gettokenbypinid_badrequest.rb'
|
||||
autoload :GetTokenByPinIdPlexErrors, 'plex_ruby_sdk/models/errors/gettokenbypinid_plex_errors.rb'
|
||||
autoload :GetTokenByPinIdErrors, 'plex_ruby_sdk/models/errors/gettokenbypinid_errors.rb'
|
||||
autoload :GetTokenByPinIdResponseBody, 'plex_ruby_sdk/models/errors/gettokenbypinid_responsebody.rb'
|
||||
autoload :GetTokenDetailsAuthenticationErrors, 'plex_ruby_sdk/models/errors/gettokendetails_authentication_errors.rb'
|
||||
autoload :GetTokenDetailsBadRequest, 'plex_ruby_sdk/models/errors/gettokendetails_badrequest.rb'
|
||||
autoload :GetTokenDetailsUnauthorized, 'plex_ruby_sdk/models/errors/gettokendetails_unauthorized.rb'
|
||||
autoload :GetTokenDetailsErrors, 'plex_ruby_sdk/models/errors/gettokendetails_errors.rb'
|
||||
autoload :GetTopWatchedContentBadRequest, 'plex_ruby_sdk/models/errors/gettopwatchedcontent_badrequest.rb'
|
||||
autoload :GetTopWatchedContentLibraryErrors, 'plex_ruby_sdk/models/errors/gettopwatchedcontent_library_errors.rb'
|
||||
autoload :GetTopWatchedContentUnauthorized, 'plex_ruby_sdk/models/errors/gettopwatchedcontent_unauthorized.rb'
|
||||
autoload :GetTopWatchedContentErrors, 'plex_ruby_sdk/models/errors/gettopwatchedcontent_errors.rb'
|
||||
autoload :GetTranscodeSessionsBadRequest, 'plex_ruby_sdk/models/errors/gettranscodesessions_badrequest.rb'
|
||||
autoload :GetTranscodeSessionsSessionsErrors, 'plex_ruby_sdk/models/errors/gettranscodesessions_sessions_errors.rb'
|
||||
autoload :GetTranscodeSessionsUnauthorized, 'plex_ruby_sdk/models/errors/gettranscodesessions_unauthorized.rb'
|
||||
autoload :GetTranscodeSessionsErrors, 'plex_ruby_sdk/models/errors/gettranscodesessions_errors.rb'
|
||||
autoload :GetTransientTokenAuthenticationErrors, 'plex_ruby_sdk/models/errors/gettransienttoken_authentication_errors.rb'
|
||||
autoload :GetTransientTokenBadRequest, 'plex_ruby_sdk/models/errors/gettransienttoken_badrequest.rb'
|
||||
autoload :GetTransientTokenUnauthorized, 'plex_ruby_sdk/models/errors/gettransienttoken_unauthorized.rb'
|
||||
autoload :GetTransientTokenErrors, 'plex_ruby_sdk/models/errors/gettransienttoken_errors.rb'
|
||||
autoload :GetUpdateStatusBadRequest, 'plex_ruby_sdk/models/errors/getupdatestatus_badrequest.rb'
|
||||
autoload :GetUpdateStatusUnauthorized, 'plex_ruby_sdk/models/errors/getupdatestatus_unauthorized.rb'
|
||||
autoload :GetUpdateStatusUpdaterErrors, 'plex_ruby_sdk/models/errors/getupdatestatus_updater_errors.rb'
|
||||
autoload :GetUpdateStatusErrors, 'plex_ruby_sdk/models/errors/getupdatestatus_errors.rb'
|
||||
autoload :GetUserFriendsBadRequest, 'plex_ruby_sdk/models/errors/getuserfriends_badrequest.rb'
|
||||
autoload :GetUserFriendsPlexErrors, 'plex_ruby_sdk/models/errors/getuserfriends_plex_errors.rb'
|
||||
autoload :GetUserFriendsUnauthorized, 'plex_ruby_sdk/models/errors/getuserfriends_unauthorized.rb'
|
||||
autoload :GetUserFriendsErrors, 'plex_ruby_sdk/models/errors/getuserfriends_errors.rb'
|
||||
autoload :LogLineBadRequest, 'plex_ruby_sdk/models/errors/logline_badrequest.rb'
|
||||
autoload :LogLineLogErrors, 'plex_ruby_sdk/models/errors/logline_log_errors.rb'
|
||||
autoload :LogLineUnauthorized, 'plex_ruby_sdk/models/errors/logline_unauthorized.rb'
|
||||
autoload :LogLineErrors, 'plex_ruby_sdk/models/errors/logline_errors.rb'
|
||||
autoload :LogMultiLineBadRequest, 'plex_ruby_sdk/models/errors/logmultiline_badrequest.rb'
|
||||
autoload :LogMultiLineLogErrors, 'plex_ruby_sdk/models/errors/logmultiline_log_errors.rb'
|
||||
autoload :LogMultiLineUnauthorized, 'plex_ruby_sdk/models/errors/logmultiline_unauthorized.rb'
|
||||
autoload :LogMultiLineErrors, 'plex_ruby_sdk/models/errors/logmultiline_errors.rb'
|
||||
autoload :MarkPlayedBadRequest, 'plex_ruby_sdk/models/errors/markplayed_badrequest.rb'
|
||||
autoload :MarkPlayedMediaErrors, 'plex_ruby_sdk/models/errors/markplayed_media_errors.rb'
|
||||
autoload :MarkPlayedUnauthorized, 'plex_ruby_sdk/models/errors/markplayed_unauthorized.rb'
|
||||
autoload :MarkPlayedErrors, 'plex_ruby_sdk/models/errors/markplayed_errors.rb'
|
||||
autoload :MarkUnplayedBadRequest, 'plex_ruby_sdk/models/errors/markunplayed_badrequest.rb'
|
||||
autoload :MarkUnplayedMediaErrors, 'plex_ruby_sdk/models/errors/markunplayed_media_errors.rb'
|
||||
autoload :MarkUnplayedUnauthorized, 'plex_ruby_sdk/models/errors/markunplayed_unauthorized.rb'
|
||||
autoload :MarkUnplayedErrors, 'plex_ruby_sdk/models/errors/markunplayed_errors.rb'
|
||||
autoload :PerformSearchBadRequest, 'plex_ruby_sdk/models/errors/performsearch_badrequest.rb'
|
||||
autoload :PerformSearchSearchErrors, 'plex_ruby_sdk/models/errors/performsearch_search_errors.rb'
|
||||
autoload :PerformSearchUnauthorized, 'plex_ruby_sdk/models/errors/performsearch_unauthorized.rb'
|
||||
autoload :PerformSearchErrors, 'plex_ruby_sdk/models/errors/performsearch_errors.rb'
|
||||
autoload :PerformVoiceSearchBadRequest, 'plex_ruby_sdk/models/errors/performvoicesearch_badrequest.rb'
|
||||
autoload :PerformVoiceSearchSearchErrors, 'plex_ruby_sdk/models/errors/performvoicesearch_search_errors.rb'
|
||||
autoload :PerformVoiceSearchUnauthorized, 'plex_ruby_sdk/models/errors/performvoicesearch_unauthorized.rb'
|
||||
autoload :PerformVoiceSearchErrors, 'plex_ruby_sdk/models/errors/performvoicesearch_errors.rb'
|
||||
autoload :PostUsersSignInDataAuthenticationErrors, 'plex_ruby_sdk/models/errors/post_users_sign_in_data_authentication_errors.rb'
|
||||
autoload :PostUsersSignInDataBadRequest, 'plex_ruby_sdk/models/errors/post_users_sign_in_data_badrequest.rb'
|
||||
autoload :PostUsersSignInDataUnauthorized, 'plex_ruby_sdk/models/errors/post_users_sign_in_data_unauthorized.rb'
|
||||
autoload :PostUsersSignInDataErrors, 'plex_ruby_sdk/models/errors/post_users_sign_in_data_errors.rb'
|
||||
autoload :StartAllTasksBadRequest, 'plex_ruby_sdk/models/errors/startalltasks_badrequest.rb'
|
||||
autoload :StartAllTasksButlerErrors, 'plex_ruby_sdk/models/errors/startalltasks_butler_errors.rb'
|
||||
autoload :StartAllTasksUnauthorized, 'plex_ruby_sdk/models/errors/startalltasks_unauthorized.rb'
|
||||
autoload :StartAllTasksErrors, 'plex_ruby_sdk/models/errors/startalltasks_errors.rb'
|
||||
autoload :StartTaskBadRequest, 'plex_ruby_sdk/models/errors/starttask_badrequest.rb'
|
||||
autoload :StartTaskButlerErrors, 'plex_ruby_sdk/models/errors/starttask_butler_errors.rb'
|
||||
autoload :StartTaskUnauthorized, 'plex_ruby_sdk/models/errors/starttask_unauthorized.rb'
|
||||
autoload :StartTaskErrors, 'plex_ruby_sdk/models/errors/starttask_errors.rb'
|
||||
autoload :StartUniversalTranscodeBadRequest, 'plex_ruby_sdk/models/errors/startuniversaltranscode_badrequest.rb'
|
||||
autoload :StartUniversalTranscodeUnauthorized, 'plex_ruby_sdk/models/errors/startuniversaltranscode_unauthorized.rb'
|
||||
autoload :StartUniversalTranscodeVideoErrors, 'plex_ruby_sdk/models/errors/startuniversaltranscode_video_errors.rb'
|
||||
autoload :StartUniversalTranscodeErrors, 'plex_ruby_sdk/models/errors/startuniversaltranscode_errors.rb'
|
||||
autoload :StopAllTasksBadRequest, 'plex_ruby_sdk/models/errors/stopalltasks_badrequest.rb'
|
||||
autoload :StopAllTasksButlerErrors, 'plex_ruby_sdk/models/errors/stopalltasks_butler_errors.rb'
|
||||
autoload :StopAllTasksUnauthorized, 'plex_ruby_sdk/models/errors/stopalltasks_unauthorized.rb'
|
||||
autoload :StopAllTasksErrors, 'plex_ruby_sdk/models/errors/stopalltasks_errors.rb'
|
||||
autoload :StopTaskBadRequest, 'plex_ruby_sdk/models/errors/stoptask_badrequest.rb'
|
||||
autoload :StopTaskButlerErrors, 'plex_ruby_sdk/models/errors/stoptask_butler_errors.rb'
|
||||
autoload :StopTaskUnauthorized, 'plex_ruby_sdk/models/errors/stoptask_unauthorized.rb'
|
||||
autoload :StopTaskErrors, 'plex_ruby_sdk/models/errors/stoptask_errors.rb'
|
||||
autoload :StopTranscodeSessionBadRequest, 'plex_ruby_sdk/models/errors/stoptranscodesession_badrequest.rb'
|
||||
autoload :StopTranscodeSessionSessionsErrors, 'plex_ruby_sdk/models/errors/stoptranscodesession_sessions_errors.rb'
|
||||
autoload :StopTranscodeSessionUnauthorized, 'plex_ruby_sdk/models/errors/stoptranscodesession_unauthorized.rb'
|
||||
autoload :StopTranscodeSessionErrors, 'plex_ruby_sdk/models/errors/stoptranscodesession_errors.rb'
|
||||
autoload :UpdatePlayProgressBadRequest, 'plex_ruby_sdk/models/errors/updateplayprogress_badrequest.rb'
|
||||
autoload :UpdatePlayProgressMediaErrors, 'plex_ruby_sdk/models/errors/updateplayprogress_media_errors.rb'
|
||||
autoload :UpdatePlayProgressUnauthorized, 'plex_ruby_sdk/models/errors/updateplayprogress_unauthorized.rb'
|
||||
autoload :UpdatePlayProgressErrors, 'plex_ruby_sdk/models/errors/updateplayprogress_errors.rb'
|
||||
autoload :UpdatePlaylistBadRequest, 'plex_ruby_sdk/models/errors/updateplaylist_badrequest.rb'
|
||||
autoload :UpdatePlaylistPlaylistsErrors, 'plex_ruby_sdk/models/errors/updateplaylist_playlists_errors.rb'
|
||||
autoload :UpdatePlaylistUnauthorized, 'plex_ruby_sdk/models/errors/updateplaylist_unauthorized.rb'
|
||||
autoload :UpdatePlaylistErrors, 'plex_ruby_sdk/models/errors/updateplaylist_errors.rb'
|
||||
autoload :UploadPlaylistBadRequest, 'plex_ruby_sdk/models/errors/uploadplaylist_badrequest.rb'
|
||||
autoload :UploadPlaylistPlaylistsErrors, 'plex_ruby_sdk/models/errors/uploadplaylist_playlists_errors.rb'
|
||||
autoload :UploadPlaylistUnauthorized, 'plex_ruby_sdk/models/errors/uploadplaylist_unauthorized.rb'
|
||||
autoload :UploadPlaylistErrors, 'plex_ruby_sdk/models/errors/uploadplaylist_errors.rb'
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class AddPlaylistContentsBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::AddPlaylistContentsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::AddPlaylistContentsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class AddPlaylistContentsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class AddPlaylistContentsPlaylistsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class AddPlaylistContentsUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::AddPlaylistContentsPlaylistsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::AddPlaylistContentsPlaylistsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
38
lib/plex_ruby_sdk/models/errors/apierror.rb
Normal file
38
lib/plex_ruby_sdk/models/errors/apierror.rb
Normal file
@@ -0,0 +1,38 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
class APIError < StandardError
|
||||
include Crystalline::MetadataFields
|
||||
extend T::Sig
|
||||
|
||||
|
||||
field :body, T.nilable(::String), { 'format_json': { 'letter_case': ::OpenApiSDK::Utils.field_name('body') } }
|
||||
field :raw_response, T.nilable(Faraday::Response), {}
|
||||
field :status_code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::OpenApiSDK::Utils.field_name('status_code') } }
|
||||
|
||||
|
||||
sig { params(status_code: ::Integer, body: ::String, raw_response: Faraday::Response).void }
|
||||
def initialize(status_code:, body:, raw_response:)
|
||||
@status_code = status_code
|
||||
@body = body
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @msg == other.msg
|
||||
return false unless @status_code == other.status_code
|
||||
return false unless @body == other.body
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
37
lib/plex_ruby_sdk/models/errors/applyupdates_badrequest.rb
Normal file
37
lib/plex_ruby_sdk/models/errors/applyupdates_badrequest.rb
Normal file
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class ApplyUpdatesBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::ApplyUpdatesErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::ApplyUpdatesErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/applyupdates_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/applyupdates_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class ApplyUpdatesErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
37
lib/plex_ruby_sdk/models/errors/applyupdates_unauthorized.rb
Normal file
37
lib/plex_ruby_sdk/models/errors/applyupdates_unauthorized.rb
Normal file
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class ApplyUpdatesUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::ApplyUpdatesUpdaterErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::ApplyUpdatesUpdaterErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class ApplyUpdatesUpdaterErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class CancelServerActivitiesActivitiesErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class CancelServerActivitiesBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::CancelServerActivitiesErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::CancelServerActivitiesErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class CancelServerActivitiesErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class CancelServerActivitiesUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::CancelServerActivitiesActivitiesErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::CancelServerActivitiesActivitiesErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class CheckForUpdatesBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::CheckForUpdatesErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::CheckForUpdatesErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/checkforupdates_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/checkforupdates_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class CheckForUpdatesErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class CheckForUpdatesUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::CheckForUpdatesUpdaterErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::CheckForUpdatesUpdaterErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class CheckForUpdatesUpdaterErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class ClearPlaylistContentsBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::ClearPlaylistContentsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::ClearPlaylistContentsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class ClearPlaylistContentsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class ClearPlaylistContentsPlaylistsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class ClearPlaylistContentsUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::ClearPlaylistContentsPlaylistsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::ClearPlaylistContentsPlaylistsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
37
lib/plex_ruby_sdk/models/errors/createplaylist_badrequest.rb
Normal file
37
lib/plex_ruby_sdk/models/errors/createplaylist_badrequest.rb
Normal file
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class CreatePlaylistBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::CreatePlaylistErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::CreatePlaylistErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/createplaylist_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/createplaylist_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class CreatePlaylistErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class CreatePlaylistPlaylistsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class CreatePlaylistUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::CreatePlaylistPlaylistsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::CreatePlaylistPlaylistsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
37
lib/plex_ruby_sdk/models/errors/deletelibrary_badrequest.rb
Normal file
37
lib/plex_ruby_sdk/models/errors/deletelibrary_badrequest.rb
Normal file
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class DeleteLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::DeleteLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::DeleteLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/deletelibrary_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/deletelibrary_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class DeleteLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class DeleteLibraryLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class DeleteLibraryUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::DeleteLibraryLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::DeleteLibraryLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
37
lib/plex_ruby_sdk/models/errors/deleteplaylist_badrequest.rb
Normal file
37
lib/plex_ruby_sdk/models/errors/deleteplaylist_badrequest.rb
Normal file
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class DeletePlaylistBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::DeletePlaylistErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::DeletePlaylistErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/deleteplaylist_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/deleteplaylist_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class DeletePlaylistErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class DeletePlaylistPlaylistsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class DeletePlaylistUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::DeletePlaylistPlaylistsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::DeletePlaylistPlaylistsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class EnablePaperTrailBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::EnablePaperTrailErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::EnablePaperTrailErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/enablepapertrail_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/enablepapertrail_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class EnablePaperTrailErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class EnablePaperTrailLogErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class EnablePaperTrailUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::EnablePaperTrailLogErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::EnablePaperTrailLogErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class Errors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetActorsLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetActorsLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetActorsLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/get_actors_library_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/get_actors_library_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetActorsLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetActorsLibraryLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetActorsLibraryUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetActorsLibraryLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetActorsLibraryLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetAllLibrariesBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetAllLibrariesErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetAllLibrariesErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/get_all_libraries_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/get_all_libraries_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetAllLibrariesErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetAllLibrariesLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetAllLibrariesUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetAllLibrariesLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetAllLibrariesLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetAllMediaLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetAllMediaLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetAllMediaLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetAllMediaLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetAllMediaLibraryLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetAllMediaLibraryUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetAllMediaLibraryLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetAllMediaLibraryLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetBannerImageBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetBannerImageErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetBannerImageErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/get_banner_image_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/get_banner_image_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetBannerImageErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetBannerImageMediaErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetBannerImageUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetBannerImageMediaErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetBannerImageMediaErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetCountriesLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetCountriesLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetCountriesLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetCountriesLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetCountriesLibraryLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetCountriesLibraryUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetCountriesLibraryLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetCountriesLibraryLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetGenresLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetGenresLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetGenresLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/get_genres_library_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/get_genres_library_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetGenresLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetGenresLibraryLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetGenresLibraryUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetGenresLibraryLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetGenresLibraryLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetLibraryDetailsBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetLibraryDetailsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetLibraryDetailsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetLibraryDetailsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetLibraryDetailsLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetLibraryDetailsUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetLibraryDetailsLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetLibraryDetailsLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetLibraryItemsBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetLibraryItemsErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetLibraryItemsErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/get_library_items_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/get_library_items_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetLibraryItemsErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetLibraryItemsLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetLibraryItemsUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetLibraryItemsLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetLibraryItemsLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetMediaMetaDataBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetMediaMetaDataErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetMediaMetaDataErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetMediaMetaDataErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetMediaMetaDataLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetMediaMetaDataUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetMediaMetaDataLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetMediaMetaDataLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetMediaProvidersBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetMediaProvidersErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetMediaProvidersErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetMediaProvidersErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetMediaProvidersServerErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetMediaProvidersUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetMediaProvidersServerErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetMediaProvidersServerErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetRecentlyAddedLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetRecentlyAddedLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetRecentlyAddedLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetRecentlyAddedLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetRecentlyAddedLibraryLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetRecentlyAddedLibraryUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetRecentlyAddedLibraryLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetRecentlyAddedLibraryLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetRefreshLibraryMetadataBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetRefreshLibraryMetadataErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetRefreshLibraryMetadataErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetRefreshLibraryMetadataErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetRefreshLibraryMetadataLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetRefreshLibraryMetadataUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetRefreshLibraryMetadataLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetRefreshLibraryMetadataLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetSearchAllLibrariesBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetSearchAllLibrariesErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetSearchAllLibrariesErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetSearchAllLibrariesErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetSearchAllLibrariesLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Unauthorized - Returned if the X-Plex-Token is missing from the header or query.
|
||||
class GetSearchAllLibrariesUnauthorized
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetSearchAllLibrariesLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetSearchAllLibrariesLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,37 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
# Bad Request - A parameter was not specified, or was specified incorrectly.
|
||||
class GetSearchLibraryBadRequest
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :errors, T.nilable(T::Array[Models::Errors::GetSearchLibraryErrors]), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('errors') } }
|
||||
# Raw HTTP response; suitable for custom response parsing
|
||||
field :raw_response, T.nilable(::Faraday::Response), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('-') } }
|
||||
|
||||
|
||||
sig { params(errors: T.nilable(T::Array[Models::Errors::GetSearchLibraryErrors]), raw_response: T.nilable(::Faraday::Response)).void }
|
||||
def initialize(errors: nil, raw_response: nil)
|
||||
@errors = errors
|
||||
@raw_response = raw_response
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @errors == other.errors
|
||||
return false unless @raw_response == other.raw_response
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
41
lib/plex_ruby_sdk/models/errors/get_search_library_errors.rb
Normal file
41
lib/plex_ruby_sdk/models/errors/get_search_library_errors.rb
Normal file
@@ -0,0 +1,41 @@
|
||||
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
||||
|
||||
# typed: true
|
||||
# frozen_string_literal: true
|
||||
|
||||
|
||||
module PlexRubySDK
|
||||
module Models
|
||||
module Errors
|
||||
|
||||
|
||||
class GetSearchLibraryErrors
|
||||
extend T::Sig
|
||||
include Crystalline::MetadataFields
|
||||
|
||||
|
||||
field :code, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('code') } }
|
||||
|
||||
field :message, T.nilable(::String), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('message') } }
|
||||
|
||||
field :status, T.nilable(::Integer), { 'format_json': { 'letter_case': ::PlexRubySDK::Utils.field_name('status') } }
|
||||
|
||||
|
||||
sig { params(code: T.nilable(::Integer), message: T.nilable(::String), status: T.nilable(::Integer)).void }
|
||||
def initialize(code: nil, message: nil, status: nil)
|
||||
@code = code
|
||||
@message = message
|
||||
@status = status
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
return false unless other.is_a? self.class
|
||||
return false unless @code == other.code
|
||||
return false unless @message == other.message
|
||||
return false unless @status == other.status
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user