test-words-api-client-sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4340cf9d35dd41ed353e9ba318b4cebde5c304c063696e57eff2efd280ae8d56
+  data.tar.gz: dd9351acfc7c32846c9f050eb64121ab083bfbbe18fd7508c219c257060eebd6
+SHA512:
+  metadata.gz: ef89f97caf264b46b81e68f9e3f7e093522b472b7bfdaac05ef142f050d8f130cd6cce07d96ac171752c517fd3192ac61e4b030c42c8e64f47a2eff378af7204
+  data.tar.gz: 7569b977c15e24e9513c9d0bb6c00a04a157636ba1af2f71a22b05df03c620781fe85a6f68c219967cc685d6f3264c8b7bb3ddc2edafb9e8a61422eb79261c0e

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2024 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,76 @@
+
+# Getting Started with Words API
+
+## Introduction
+
+Words API lets you retrieve information about English words, including definitions, synonyms, rhymes, pronunciation, syllables, and frequency of usage. It also can tell you about relationships between words, for instance that “math” has categories like “algebra” and “geometry”, or that a “finger” is part of a “hand”.
+
+## Install the Package
+
+Install the gem from the command line:
+
+```ruby
+gem install test-words-api-client-sdk -v 1.0.0
+```
+
+Or add the gem to your Gemfile and run `bundle`:
+
+```ruby
+gem 'test-words-api-client-sdk', '1.0.0'
+```
+
+For additional gem details, see the [RubyGems page for the test-words-api-client-sdk gem](https://rubygems.org/gems/test-words-api-client-sdk/versions/1.0.0).
+
+## Test the SDK
+
+To run the tests, navigate to the root directory of the SDK in your terminal and execute the following command:
+
+```
+rake
+```
+
+## Initialize the API Client
+
+**_Note:_** Documentation for the client can be found [here.](doc/client.md)
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| `connection` | `Faraday::Connection` | The Faraday connection object passed by the SDK user for making requests |
+| `adapter` | `Faraday::Adapter` | The Faraday adapter object passed by the SDK user for performing http requests |
+| `timeout` | `Float` | The value to use for connection timeout. <br> **Default: 60** |
+| `max_retries` | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
+| `retry_interval` | `Float` | Pause in seconds between retries. <br> **Default: 1** |
+| `backoff_factor` | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
+| `retry_statuses` | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| `retry_methods` | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+| `http_callback` | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
+| `custom_header_authentication_credentials` | [`CustomHeaderAuthenticationCredentials`](__base_path/auth/custom-header-signature.md) | The credential object for Custom Header Signature |
+
+The API client can be initialized as follows:
+
+```ruby
+client = WordsApi::Client.new(
+  custom_header_authentication_credentials: CustomHeaderAuthenticationCredentials.new(
+    x_rapid_api_key: 'X-RapidAPI-Key'
+  )
+)
+```
+
+## Authorization
+
+This API uses the following authentication schemes.
+
+* [`RapidAPI-Key (Custom Header Signature)`](__base_path/auth/custom-header-signature.md)
+
+## List of APIs
+
+* [AP Is](doc/controllers/ap-is.md)
+
+## Classes Documentation
+
+* [Utility Classes](doc/utility-classes.md)
+* [HttpResponse](doc/http-response.md)
+* [HttpRequest](doc/http-request.md)
+

data/lib/words_api/api_helper.rb

@@ -0,0 +1,10 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # API utility class
+  class APIHelper < CoreLibrary::ApiHelper
+  end
+end

data/lib/words_api/client.rb

@@ -0,0 +1,60 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  #  words_api client class.
+  class Client
+    include CoreLibrary
+    attr_reader :config, :auth_managers
+
+    # Access to ap_is controller.
+    # @return [APIsController] Returns the controller instance.
+    def ap_is
+      @ap_is ||= APIsController.new @global_configuration
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 60,
+      max_retries: 0, retry_interval: 1, backoff_factor: 2,
+      retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+      retry_methods: %i[get put], http_callback: nil,
+      environment: Environment::PRODUCTION, x_rapid_api_key: nil,
+      custom_header_authentication_credentials: nil, config: nil
+    )
+      @config = if config.nil?
+                  Configuration.new(
+                    connection: connection, adapter: adapter, timeout: timeout,
+                    max_retries: max_retries, retry_interval: retry_interval,
+                    backoff_factor: backoff_factor,
+                    retry_statuses: retry_statuses,
+                    retry_methods: retry_methods, http_callback: http_callback,
+                    environment: environment, x_rapid_api_key: x_rapid_api_key,
+                    custom_header_authentication_credentials: custom_header_authentication_credentials
+                  )
+                else
+                  config
+                end
+
+      @global_configuration = GlobalConfiguration.new(client_configuration: @config)
+                                                 .base_uri_executor(@config.method(:get_base_uri))
+                                                 .global_errors(BaseController::GLOBAL_ERRORS)
+                                                 .user_agent(BaseController.user_agent)
+
+      initialize_auth_managers(@global_configuration)
+      @global_configuration = @global_configuration.auth_managers(@auth_managers)
+    end
+
+    # Initializes the auth managers hash used for authenticating API calls.
+    # @param [GlobalConfiguration] global_config The global configuration of the SDK)
+    def initialize_auth_managers(global_config)
+      @auth_managers = {}
+      http_client_config = global_config.client_configuration
+      %w[RapidAPI-Key].each { |auth| @auth_managers[auth] = nil }
+      @auth_managers['RapidAPI-Key'] = CustomHeaderAuthentication.new(
+        http_client_config.custom_header_authentication_credentials
+      )
+    end
+  end
+end

data/lib/words_api/configuration.rb

@@ -0,0 +1,127 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # An enum for SDK environments.
+  class Environment
+    ENVIRONMENT = [
+      PRODUCTION = 'production'.freeze
+    ].freeze
+  end
+
+  # An enum for API servers.
+  class Server
+    SERVER = [
+      DEFAULT = 'default'.freeze
+    ].freeze
+  end
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration < CoreLibrary::HttpClientConfiguration
+    def x_rapid_api_key
+      @custom_header_authentication_credentials.x_rapid_api_key
+    end
+
+    # The attribute readers for properties.
+    attr_reader :environment, :custom_header_authentication_credentials
+
+    class << self
+      attr_reader :environments
+    end
+
+    def initialize(
+      connection: nil, adapter: :net_http_persistent, timeout: 60,
+      max_retries: 0, retry_interval: 1, backoff_factor: 2,
+      retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+      retry_methods: %i[get put], http_callback: nil,
+      environment: Environment::PRODUCTION, x_rapid_api_key: nil,
+      custom_header_authentication_credentials: nil
+    )
+
+      super connection: connection, adapter: adapter, timeout: timeout,
+            max_retries: max_retries, retry_interval: retry_interval,
+            backoff_factor: backoff_factor, retry_statuses: retry_statuses,
+            retry_methods: retry_methods, http_callback: http_callback
+
+      # Current API environment
+      @environment = String(environment)
+
+      # This is an API key from RapidAPI.
+      @x_rapid_api_key = x_rapid_api_key
+
+      # Initializing Custom Header Signature credentials with the provided auth parameters
+      @custom_header_authentication_credentials = create_auth_credentials_object(
+        x_rapid_api_key, custom_header_authentication_credentials
+      )
+
+      # The Http Client to use for making requests.
+      set_http_client CoreLibrary::FaradayClient.new(self)
+    end
+
+    def clone_with(connection: nil, adapter: nil, timeout: nil,
+                   max_retries: nil, retry_interval: nil, backoff_factor: nil,
+                   retry_statuses: nil, retry_methods: nil, http_callback: nil,
+                   environment: nil, x_rapid_api_key: nil,
+                   custom_header_authentication_credentials: nil)
+      connection ||= self.connection
+      adapter ||= self.adapter
+      timeout ||= self.timeout
+      max_retries ||= self.max_retries
+      retry_interval ||= self.retry_interval
+      backoff_factor ||= self.backoff_factor
+      retry_statuses ||= self.retry_statuses
+      retry_methods ||= self.retry_methods
+      http_callback ||= self.http_callback
+      environment ||= self.environment
+      custom_header_authentication_credentials = create_auth_credentials_object(
+        x_rapid_api_key,
+        custom_header_authentication_credentials || self.custom_header_authentication_credentials
+      )
+
+      Configuration.new(
+        connection: connection, adapter: adapter, timeout: timeout,
+        max_retries: max_retries, retry_interval: retry_interval,
+        backoff_factor: backoff_factor, retry_statuses: retry_statuses,
+        retry_methods: retry_methods, http_callback: http_callback,
+        environment: environment,
+        custom_header_authentication_credentials: custom_header_authentication_credentials
+      )
+    end
+
+    def create_auth_credentials_object(x_rapid_api_key,
+                                       custom_header_authentication_credentials)
+      return custom_header_authentication_credentials if x_rapid_api_key.nil?
+
+      warn('The \'x_rapid_api_key\' params are deprecated. Use \'custom_header'\
+           '_authentication_credentials\' param instead.')
+
+      unless custom_header_authentication_credentials.nil?
+        return custom_header_authentication_credentials.clone_with(
+          x_rapid_api_key: x_rapid_api_key
+        )
+      end
+
+      CustomHeaderAuthenticationCredentials.new(
+        x_rapid_api_key: x_rapid_api_key
+      )
+    end
+
+    # All the environments the SDK can run in.
+    ENVIRONMENTS = {
+      Environment::PRODUCTION => {
+        Server::DEFAULT => 'https://wordsapiv1.p.rapidapi.com'
+      }
+    }.freeze
+
+    # Generates the appropriate base URI for the environment and the server.
+    # @param [Configuration::Server] server The server enum for which the base URI is
+    # required.
+    # @return [String] The base URI.
+    def get_base_uri(server = Server::DEFAULT)
+      ENVIRONMENTS[environment][server].clone
+    end
+  end
+end

data/lib/words_api/controllers/ap_is_controller.rb

@@ -0,0 +1,134 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # APIsController
+  class APIsController < BaseController
+    # Get synonyms of a word.
+    # @param [String] word Required parameter: The word to search synonyms
+    # for.
+    # @return [SynonymsResponse] response from the API call.
+    def synonyms(word)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/words/{word}/synonyms',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(word, key: 'word')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('RapidAPI-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SynonymsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get definitions of a word, including the part of speech.
+    # @param [String] word Required parameter: The word to search the
+    # definitions for.
+    # @return [DefinitionsResponse] response from the API call.
+    def definitions(word)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/words/{word}/definitions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(word, key: 'word')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('RapidAPI-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DefinitionsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # How to pronounce a word, according to the International Phonetic Alphabet.
+    # May include multiple results if the word is pronounced differently
+    # depending on its part of speech.
+    # @param [String] word Required parameter: The word to search pronunciation
+    # for.
+    # @return [PronunciationResponse] response from the API call.
+    def pronunciation(word)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/words/{word}/pronunciation',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(word, key: 'word')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('RapidAPI-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PronunciationResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Retrieve information about a word. Results can include definitions, part
+    # of speech, synonyms, related words, syllables, and pronunciation. This
+    # method is useful to see which relationships are attached to which
+    # definition and part of speech of a word.
+    # @param [String] word Required parameter: This is a template parameter that
+    # is used to provide the word, about which the information is being
+    # fetched.
+    # @return [WordResponse] response from the API call.
+    def word(word)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/words/{word}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(word, key: 'word')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('RapidAPI-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WordResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get examples of how the word is used.
+    # @param [String] word Required parameter: The word to search the examples
+    # for.
+    # @return [ExamplesResponse] response from the API call.
+    def examples(word)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/words/{word}/examples',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(word, key: 'word')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('RapidAPI-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ExamplesResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Expands upon the frequency score returned by the main /words/{word}
+    # endpoint. Returns zipf, a score indicating how common the word is in the
+    # English language, with a range of 1 to 7; per Million, the number of times
+    # the word is likely to appear in a corpus of one million English words; and
+    # diversity, a 0-1 scale the shows the likelihood of the word appearing in
+    # an English document that is part of a corpus.
+    # @param [String] word Required parameter: The word to search frequency
+    # for.
+    # @return [FrequencyResponse] response from the API call.
+    def frequency(word)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/words/{word}/frequency',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(word, key: 'word')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('RapidAPI-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(FrequencyResponse.method(:from_hash)))
+        .execute
+    end
+  end
+end

data/lib/words_api/controllers/base_controller.rb

@@ -0,0 +1,66 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # BaseController.
+  class BaseController
+    include CoreLibrary
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'APIMATIC 3.0'
+    end
+
+
+    GLOBAL_ERRORS = {
+      'default' => ErrorCase.new
+                            .error_message('HTTP response not OK.')
+                            .exception_type(APIException)
+    }.freeze
+
+    # Initialization constructor.
+    # @param [GlobalConfiguration] global_configuration The instance of GlobalConfiguration.
+    def initialize(global_configuration)
+      @global_configuration = global_configuration
+      @config = @global_configuration.client_configuration
+      @http_call_back = @config.http_callback
+      @api_call = ApiCall.new(@global_configuration)
+    end
+
+    # Creates a new builder for the Api Call instance.
+    # @return [ApiCall] The instance of ApiCall.
+    def new_api_call_builder
+      @api_call.new_builder
+    end
+
+    # Creates a new instance of the request builder.
+    # @param [String] http_method The HTTP method to use in the request.
+    # @param [String] path The endpoint path to use in the request.
+    # @param [String] server The server to extract the base uri for the request.
+    # @return [RequestBuilder] The instance of RequestBuilder.
+    def new_request_builder(http_method, path, server)
+      RequestBuilder.new
+                    .http_method(http_method)
+                    .path(path)
+                    .server(server)
+    end
+
+    # Creates a new instance of the response handler.
+    # @return [ResponseHandler] The instance of ResponseHandler.
+    def new_response_handler
+      ResponseHandler.new
+    end
+
+    # Creates a new instance of the parameter.
+    # @param [String|optional] key The key of the parameter.
+    # @param [Object] value The value of the parameter.
+    # @return [Parameter] The instance of Parameter.
+    def new_parameter(value, key: nil)
+      Parameter.new
+               .key(key)
+               .value(value)
+    end
+  end
+end

data/lib/words_api/exceptions/api_exception.rb

@@ -0,0 +1,10 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # Class for exceptions when there is a network error, status code error, etc.
+  class APIException < CoreLibrary::ApiException
+  end
+end

data/lib/words_api/http/auth/custom_header_authentication.rb

@@ -0,0 +1,44 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # Utility class for custom header authorization.
+  class CustomHeaderAuthentication < CoreLibrary::HeaderAuth
+    # Display error message on occurrence of authentication failure.
+    # @returns [String] The oAuth error message.
+    def error_message
+      'CustomHeaderAuthentication: x_rapid_api_key is undefined.'
+    end
+
+    # Initialization constructor.
+    def initialize(custom_header_authentication_credentials)
+      auth_params = {}
+      auth_params['X-RapidAPI-Key'] = custom_header_authentication_credentials.x_rapid_api_key unless
+        custom_header_authentication_credentials.nil? || custom_header_authentication_credentials.x_rapid_api_key.nil?
+
+      super auth_params
+    end
+  end
+
+  # Data class for CustomHeaderAuthenticationCredentials.
+  # Data class for CustomHeaderAuthenticationCredentials.
+  class CustomHeaderAuthenticationCredentials
+    attr_reader :x_rapid_api_key
+
+    def initialize(x_rapid_api_key:)
+      raise ArgumentError, 'x_rapid_api_key cannot be nil' if x_rapid_api_key.nil?
+
+      @x_rapid_api_key = x_rapid_api_key
+    end
+
+    def clone_with(x_rapid_api_key: nil)
+      x_rapid_api_key ||= self.x_rapid_api_key
+
+      CustomHeaderAuthenticationCredentials.new(
+        x_rapid_api_key: x_rapid_api_key
+      )
+    end
+  end
+end

data/lib/words_api/http/http_call_back.rb

@@ -0,0 +1,10 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # HttpCallBack allows defining callables for pre and post API calls.
+  class HttpCallBack < CoreLibrary::HttpCallback
+  end
+end

data/lib/words_api/http/http_method_enum.rb

@@ -0,0 +1,10 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # HTTP Methods Enumeration.
+  class HttpMethodEnum < CoreLibrary::HttpMethod
+  end
+end

data/lib/words_api/http/http_request.rb

@@ -0,0 +1,10 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # Represents a single Http Request.
+  class HttpRequest < CoreLibrary::HttpRequest
+  end
+end

data/lib/words_api/http/http_response.rb

@@ -0,0 +1,10 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # Http response received.
+  class HttpResponse < CoreLibrary::HttpResponse
+  end
+end

data/lib/words_api/models/base_model.rb

@@ -0,0 +1,62 @@
+# words_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module WordsApi
+  # Base model.
+  class BaseModel < CoreLibrary::BaseModel
+    # Returns a Hash representation of the current object.
+    def to_hash
+      # validating the model being serialized
+      self.class.validate(self) if self.class.respond_to?(:validate)
+
+      hash = {}
+      instance_variables.each do |name|
+        value = instance_variable_get(name)
+        name = name[1..]
+        key = self.class.names.key?(name) ? self.class.names[name] : name
+        optional_fields = self.class.optionals
+        nullable_fields = self.class.nullables
+        if value.nil?
+          next unless nullable_fields.include?(name)
+
+          if !optional_fields.include?(name) && !nullable_fields.include?(name)
+            raise ArgumentError,
+                  "`#{name}` cannot be nil in `#{self.class}`. Please specify a valid value."
+          end
+        end
+
+        hash[key] = nil
+        unless value.nil?
+          if respond_to?("to_custom_#{name}")
+            if (value.instance_of? Array) || (value.instance_of? Hash)
+              params = [hash, key]
+              hash[key] = send("to_custom_#{name}", *params)
+            else
+              hash[key] = send("to_custom_#{name}")
+            end
+          elsif respond_to?("to_union_type_#{name}")
+            hash[key] = send("to_union_type_#{name}")
+          elsif value.instance_of? Array
+            hash[key] = value.map { |v| v.is_a?(BaseModel) ? v.to_hash : v }
+          elsif value.instance_of? Hash
+            hash[key] = {}
+            value.each do |k, v|
+              hash[key][k] = v.is_a?(BaseModel) ? v.to_hash : v
+            end
+          else
+            hash[key] = value.is_a?(BaseModel) ? value.to_hash : value
+          end
+        end
+      end
+      hash
+    end
+
+    # Returns a JSON representation of the curent object.
+    def to_json(options = {})
+      hash = to_hash
+      hash.to_json(options)
+    end
+  end
+end