dub 0.9.0 → 0.10.1

data/lib/open_api_sdk/qr_codes.rb

@@ -14,45 +14,66 @@ module OpenApiSDK
   extend T::Sig
   class QRCodes
     extend T::Sig
+    
 
 
     sig { params(sdk_config: SDKConfiguration).void }
     def initialize(sdk_config)
       @sdk_configuration = sdk_config
+      
     end
 
+    sig { params(base_url: String, url_variables: T.nilable(T::Hash[Symbol, T.any(String, T::Enum)])).returns(String) }
+    def get_url(base_url:, url_variables: nil)
+      sd_base_url, sd_options = @sdk_configuration.get_server_details
+
+      if base_url.nil?
+        base_url = sd_base_url
+      end
+
+      if url_variables.nil?
+        url_variables = sd_options
+      end
 
-    sig { params(request: T.nilable(::OpenApiSDK::Operations::GetQRCodeRequest), timeout_ms: T.nilable(Integer)).returns(::OpenApiSDK::Operations::GetQRCodeResponse) }
-    def get(request, timeout_ms = nil)
+      return Utils.template_url base_url, url_variables
+    end
+
+
+    sig { params(request: Models::Operations::GetQRCodeRequest, timeout_ms: T.nilable(Integer)).returns(::String) }
+    def get(request:, timeout_ms: nil)
       # get - Retrieve a QR code
       # Retrieve a QR code for a link.
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = "#{base_url}/qr"
       headers = {}
-      query_params = Utils.get_query_params(::OpenApiSDK::Operations::GetQRCodeRequest, request)
-      headers['Accept'] = 'application/json;q=1, image/png;q=0'
+      headers = T.cast(headers, T::Hash[String, String])
+      query_params = Utils.get_query_params(Models::Operations::GetQRCodeRequest, request, nil)
+      headers['Accept'] = 'image/png'
       headers['user-agent'] = @sdk_configuration.user_agent
 
-      security = !@sdk_configuration.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
+      security = @sdk_configuration.security_source&.call
 
       timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
       timeout ||= @sdk_configuration.timeout
+      
 
       connection = @sdk_configuration.client
 
       hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
         base_url: base_url,
-        oauth2_scopes: nil,
+        oauth2_scopes: [],
         operation_id: 'getQRCode',
         security_source: @sdk_configuration.security_source
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.get(url) do |req|
+        http_response = T.must(connection).get(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           req.params = query_params
@@ -68,84 +89,176 @@ module OpenApiSDK
       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 = ::OpenApiSDK::Operations::GetQRCodeResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
-        res.res = r.env.response_body if Utils.match_content_type(content_type, 'image/png')
-      elsif r.status == 400
+      
+      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/png')
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          return http_response.env.body
+        else
+          raise ::OpenApiSDK::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')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::BadRequest)
-          res.bad_request = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequest)
+          raise obj
+        else
+          raise ::OpenApiSDK::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), ::OpenApiSDK::Shared::Unauthorized)
-          res.unauthorized = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::Unauthorized)
+          raise obj
+        else
+          raise ::OpenApiSDK::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'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::Forbidden)
-          res.forbidden = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::Forbidden)
+          raise obj
+        else
+          raise ::OpenApiSDK::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'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::NotFound)
-          res.not_found = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotFound)
+          raise obj
+        else
+          raise ::OpenApiSDK::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 == 409
+      elsif Utils.match_status_code(http_response.status, ['409'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::Conflict)
-          res.conflict = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::Conflict)
+          raise obj
+        else
+          raise ::OpenApiSDK::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 == 410
+      elsif Utils.match_status_code(http_response.status, ['410'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::InviteExpired)
-          res.invite_expired = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::InviteExpired)
+          raise obj
+        else
+          raise ::OpenApiSDK::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 == 422
+      elsif Utils.match_status_code(http_response.status, ['422'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::UnprocessableEntity)
-          res.unprocessable_entity = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::UnprocessableEntity)
+          raise obj
+        else
+          raise ::OpenApiSDK::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 == 429
+      elsif Utils.match_status_code(http_response.status, ['429'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::RateLimitExceeded)
-          res.rate_limit_exceeded = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RateLimitExceeded)
+          raise obj
+        else
+          raise ::OpenApiSDK::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 == 500
+      elsif Utils.match_status_code(http_response.status, ['500'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::OpenApiSDK::Shared::InternalServerError)
-          res.internal_server_error = out
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::InternalServerError)
+          raise obj
+        else
+          raise ::OpenApiSDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::OpenApiSDK::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 ::OpenApiSDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::OpenApiSDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
   end
 end

data/lib/open_api_sdk/sdk_hooks/hooks.rb

@@ -6,7 +6,6 @@
 require_relative './registration'
 require_relative './types'
 
-require 'sorbet-runtime'
 
 module OpenApiSDK
   module SDKHooks
@@ -15,45 +14,40 @@ module OpenApiSDK
 
       sig { void }
       def initialize
-        @sdk_init_hooks = T.let([], T::Array[AbstractSDKInitHook])
-        @before_request_hooks = T.let([], T::Array[AbstractBeforeRequestHook])
-        @after_success_hooks = T.let([], T::Array[AbstractAfterSuccessHook])
-        @after_error_hooks = T.let([], T::Array[AbstractAfterErrorHook])
+        @sdk_init_hooks = T.let([], T::Array[AbstractSDKHook])
+        @before_request_hooks = T.let([], T::Array[AbstractSDKHook])
+        @after_success_hooks = T.let([], T::Array[AbstractSDKHook])
+        @after_error_hooks = T.let([], T::Array[AbstractSDKHook])
         Registration.init_hooks self
       end
 
-      sig { params(hook: AbstractSDKInitHook).void }
+      sig { params(hook: AbstractSDKHook).void }
       def register_sdk_init_hook(hook)
         @sdk_init_hooks << hook
       end
 
-      sig { params(hook: AbstractBeforeRequestHook).void }
+      sig { params(hook: AbstractSDKHook).void }
       def register_before_request_hook(hook)
         @before_request_hooks << hook
       end
 
-      sig { params(hook: AbstractAfterSuccessHook).void }
+      sig { params(hook: AbstractSDKHook).void }
       def register_after_success_hook(hook)
         @after_success_hooks << hook
       end
 
-      sig { params(hook: AbstractAfterErrorHook).void }
+      sig { params(hook: AbstractSDKHook).void }
       def register_after_error_hook(hook)
         @after_error_hooks << hook
       end
 
-      sig do
-        params(
-          base_url: String,
-          client: Faraday::Connection
-        ).returns([String, Faraday::Connection])
-      end
-      def sdk_init(base_url:, client:)
+      sig { params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
         @sdk_init_hooks.each do |hook|
-          base_url, client = hook.sdk_init(base_url: base_url, client: client)
+          config = hook.sdk_init(config: config)
         end
 
-        return base_url, client
+        return config
       end
 
       sig do

data/lib/open_api_sdk/sdk_hooks/types.rb

@@ -3,13 +3,16 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'sorbet-runtime'
+require_relative '../sdkconfiguration'
 
 module OpenApiSDK
   module SDKHooks
     class HookContext
       extend T::Sig
 
+      sig { returns(SDKConfiguration) }
+      attr_accessor :config
+
       sig { returns(String) }
       attr_accessor :base_url
 
@@ -24,13 +27,15 @@ module OpenApiSDK
 
       sig do
         params(
+          config: SDKConfiguration,
           base_url: String,
           oauth2_scopes: T.nilable(T::Array[String]),
           operation_id: String,
           security_source: T.nilable(T.proc.returns(T.untyped))
         ).void
       end
-      def initialize(base_url:, oauth2_scopes:, operation_id:, security_source:)
+      def initialize(config:, base_url:, oauth2_scopes:, operation_id:, security_source:)
+        @config = T.let(config, SDKConfiguration)
         @base_url = T.let(base_url, String)
         @oauth2_scopes = T.let(oauth2_scopes, T.nilable(T::Array[String]))
         @operation_id = T.let(operation_id, String)
@@ -48,6 +53,7 @@ module OpenApiSDK
       end
       def initialize(hook_ctx:)
         super(
+          config: hook_ctx.config,
           base_url: hook_ctx.base_url,
           operation_id: hook_ctx.operation_id,
           oauth2_scopes: hook_ctx.oauth2_scopes,
@@ -66,6 +72,7 @@ module OpenApiSDK
       end
       def initialize(hook_ctx:)
         super(
+          config: hook_ctx.config,
           base_url: hook_ctx.base_url,
           operation_id: hook_ctx.operation_id,
           oauth2_scopes: hook_ctx.oauth2_scopes,
@@ -84,6 +91,7 @@ module OpenApiSDK
       end
       def initialize(hook_ctx:)
         super(
+          config: hook_ctx.config,
           base_url: hook_ctx.base_url,
           operation_id: hook_ctx.operation_id,
           oauth2_scopes: hook_ctx.oauth2_scopes,
@@ -97,13 +105,10 @@ module OpenApiSDK
       extend T::Helpers
       abstract!
 
-      sig do
-        abstract.params(
-          base_url: String,
-          client: Faraday::Connection
-        ).returns([String, Faraday::Connection])
+      sig { overridable.params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        Kernel.raise NotImplementedError.new
       end
-      def sdk_init(base_url:, client:); end
     end
 
     module AbstractBeforeRequestHook
@@ -112,12 +117,14 @@ module OpenApiSDK
       abstract!
 
       sig do
-        abstract.params(
+        overridable.params(
           hook_ctx: BeforeRequestHookContext,
           request: Faraday::Request
         ).returns(Faraday::Request)
       end
-      def before_request(hook_ctx:, request:); end
+      def before_request(hook_ctx:, request:)
+        Kernel.raise NotImplementedError.new
+      end
     end
 
     module AbstractAfterSuccessHook
@@ -126,12 +133,14 @@ module OpenApiSDK
       abstract!
 
       sig do
-        abstract.params(
+        overridable.params(
           hook_ctx: AfterSuccessHookContext,
           response: Faraday::Response
         ).returns(Faraday::Response)
       end
-      def after_success(hook_ctx:, response:); end
+      def after_success(hook_ctx:, response:)
+        Kernel.raise NotImplementedError.new
+      end
     end
 
     module AbstractAfterErrorHook
@@ -140,13 +149,22 @@ module OpenApiSDK
       abstract!
 
       sig do
-        abstract.params(
+        overridable.params(
           error: T.nilable(StandardError),
           hook_ctx: AfterErrorHookContext,
           response: T.nilable(Faraday::Response)
         ).returns(T.nilable(Faraday::Response))
       end
-      def after_error(error:, hook_ctx:, response:); end
+      def after_error(error:, hook_ctx:, response:)
+        Kernel.raise NotImplementedError.new
+      end
+    end
+
+    class AbstractSDKHook
+      include AbstractSDKInitHook
+      include AbstractBeforeRequestHook
+      include AbstractAfterSuccessHook
+      include AbstractAfterErrorHook
     end
   end
 end

data/lib/open_api_sdk/sdkconfiguration.rb

@@ -16,23 +16,51 @@ module OpenApiSDK
   SERVERS = [
     'https://api.dub.co', # 1 - Production API
   ].freeze
+  SERVERS = T.let(SERVERS, T::Array[String])
   # Contains the list of servers available to the SDK
 
-  class SDKConfiguration < ::Crystalline::FieldAugmented
+  class SDKConfiguration
     extend T::Sig
 
-    field :client, T.nilable(Faraday::Connection)
-    field :hooks, ::OpenApiSDK::SDKHooks::Hooks
-    field :retry_config, T.nilable(::OpenApiSDK::Utils::RetryConfig)
-    field :timeout, T.nilable(Float)
-    field :security_source, T.nilable(T.proc.returns(T.nilable(::OpenApiSDK::Shared::Security)))
-    field :server_url, T.nilable(String)
-    field :server_idx, T.nilable(Integer)
-    field :language, String
-    field :openapi_doc_version, String
-    field :sdk_version, String
-    field :gen_version, String
-    field :user_agent, String
+    sig { returns(T.nilable(Faraday::Connection)) }
+    attr_accessor :client
+
+    sig { returns(::OpenApiSDK::SDKHooks::Hooks) }
+    attr_accessor :hooks
+
+    sig { returns(T.nilable(::OpenApiSDK::Utils::RetryConfig)) }
+    attr_accessor :retry_config
+
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    
+    sig { returns(T.nilable(T.proc.returns(T.nilable(Models::Shared::Security)))) }
+    attr_accessor :security_source
+
+    
+    sig { returns(T.nilable(String)) }
+    attr_accessor :server_url
+
+    
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :server_idx
+
+    
+    sig { returns(String) }
+    attr_accessor :language
+
+    sig { returns(String) }
+    attr_accessor :openapi_doc_version
+
+    sig { returns(String) }
+    attr_accessor :sdk_version
+
+    sig { returns(String) }
+    attr_accessor :gen_version
+
+    sig { returns(String) }
+    attr_accessor :user_agent
 
     sig do
       params(
@@ -40,8 +68,8 @@ module OpenApiSDK
         hooks: ::OpenApiSDK::SDKHooks::Hooks,
         retry_config: T.nilable(::OpenApiSDK::Utils::RetryConfig),
         timeout_ms: T.nilable(Integer),
-        security: T.nilable(::OpenApiSDK::Shared::Security),
-        security_source: T.nilable(T.proc.returns(::OpenApiSDK::Shared::Security)),
+        security: T.nilable(Models::Shared::Security),
+        security_source: T.nilable(T.proc.returns(Models::Shared::Security)),
         server_url: T.nilable(String),
         server_idx: T.nilable(Integer)
       ).void
@@ -61,15 +89,16 @@ module OpenApiSDK
       end
       @language = 'ruby'
       @openapi_doc_version = '0.0.1'
-      @sdk_version = '0.9.0'
-      @gen_version = '2.563.0'
-      @user_agent = 'speakeasy-sdk/ruby 0.9.0 2.563.0 0.0.1 dub'
+      @sdk_version = '0.10.1'
+      @gen_version = '2.687.1'
+      @user_agent = 'speakeasy-sdk/ruby 0.10.1 2.687.1 0.0.1 dub'
     end
 
     sig { returns([String, T::Hash[Symbol, String]]) }
     def get_server_details
       return [@server_url.delete_suffix('/'), {}] if !@server_url.nil?
-      [SERVERS[@server_idx], {}]
+      @server_idx = T.must(@server_idx)
+      [T.must(SERVERS[@server_idx]), {}]
     end
   end
 end

data/lib/open_api_sdk/sdkconfiguration.rbi

@@ -0,0 +1,57 @@
+# typed: true
+
+class OpenApiSDK::SDKConfiguration
+  extend ::Crystalline::MetadataFields::ClassMethods
+
+  def client(); end
+
+  def client=(client); end
+
+  def gen_version(); end
+
+  def gen_version=(gen_version); end
+
+  def hooks(); end
+
+  def hooks=(hooks); end
+
+  def language(); end
+
+  def language=(language); end
+
+  def openapi_doc_version(); end
+
+  def openapi_doc_version=(openapi_doc_version); end
+
+  def retry_config(); end
+
+  def retry_config=(retry_config); end
+
+  def sdk_version(); end
+
+  def sdk_version=(sdk_version); end
+
+  def security_source(); end
+
+  def security_source=(security_source); end
+
+  def server_idx(); end
+
+  def server_idx=(server_idx); end
+
+  def server_params(); end
+
+  def server_params=(server_params); end
+
+  def server_url(); end
+
+  def server_url=(server_url); end
+
+  def timeout(); end
+
+  def timeout=(timeout); end
+
+  def user_agent(); end
+
+  def user_agent=(user_agent); end
+end