translationApiClient 1.0.3

data/lib/translationApi_client/models/base_object.rb

@@ -0,0 +1,87 @@
+module TranslationApiClient
+  # base class containing fundamental method such as to_hash, build_from_hash and more
+  class BaseObject
+
+    # return the object in the form of hash
+    def to_body
+      body = {}
+      self.class.attribute_map.each_pair do |key, value|
+        body[value] = self.send(key) unless self.send(key).nil?
+      end
+      body
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^array\[(.*)\]/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :string
+        value.to_s
+      when :number
+        value.to_i
+      when :object
+        OpenStruct.new(value)
+        when :int
+        value.to_i
+      when :double
+        value.to_f
+      when :boolean
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      else # model
+        _model = TranslationApiClient.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    # to_body is an alias to to_body (backward compatibility)
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |key, value|
+        if self.send(key).is_a?(Array)
+          next if self.send(key).empty?
+          hash[value] = self.send(key).select{|v| !v.nil?}.map{ |v| _to_hash v} unless self.send(key).nil?
+        else
+          unless (_tmp_value = _to_hash self.send(key)).nil?
+            hash[value] = _tmp_value
+          end
+        end
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/translationApi_client/models/language_pair.rb

@@ -0,0 +1,54 @@
+module TranslationApiClient
+  # 
+  class LanguagePair < BaseObject
+    attr_accessor :source, :target, :profile_ids
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Source language
+        :'source' => :'source',
+        
+        # Target language
+        :'target' => :'target',
+        
+        # Array of profile identifiers
+        :'profile_ids' => :'profileIds'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'source' => :'string',
+        :'target' => :'string',
+        :'profile_ids' => :'array[ProfileId]'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'source']
+        @source = attributes[:'source']
+      end
+      
+      if attributes[:'target']
+        @target = attributes[:'target']
+      end
+      
+      if attributes[:'profileIds']
+        if (value = attributes[:'profileIds']).is_a?(Array)
+          @profile_ids = value
+        end
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/profile.rb

@@ -0,0 +1,68 @@
+module TranslationApiClient
+  # 
+  class Profile < BaseObject
+    attr_accessor :id, :localization, :name, :source, :target
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Profile identifier
+        :'id' => :'id',
+        
+        # Localization of the profile name
+        :'localization' => :'localization',
+        
+        # Name
+        :'name' => :'name',
+        
+        # Source
+        :'source' => :'source',
+        
+        # Target
+        :'target' => :'target'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'id' => :'int',
+        :'localization' => :'object',
+        :'name' => :'string',
+        :'source' => :'string',
+        :'target' => :'string'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'id']
+        @id = attributes[:'id']
+      end
+      
+      if attributes[:'localization']
+        @localization = attributes[:'localization']
+      end
+      
+      if attributes[:'name']
+        @name = attributes[:'name']
+      end
+      
+      if attributes[:'source']
+        @source = attributes[:'source']
+      end
+      
+      if attributes[:'target']
+        @target = attributes[:'target']
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/profile_id.rb

@@ -0,0 +1,44 @@
+module TranslationApiClient
+  # 
+  class ProfileId < BaseObject
+    attr_accessor :id, :private
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Profile identifier
+        :'id' => :'id',
+        
+        # Public or private profile
+        :'private' => :'private'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'id' => :'int',
+        :'private' => :'boolean'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'id']
+        @id = attributes[:'id']
+      end
+      
+      if attributes[:'private']
+        @private = attributes[:'private']
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/profiles_response.rb

@@ -0,0 +1,38 @@
+module TranslationApiClient
+  # 
+  class ProfilesResponse < BaseObject
+    attr_accessor :profiles
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Array of profiles
+        :'profiles' => :'profiles'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'profiles' => :'array[Profile]'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'profiles']
+        if (value = attributes[:'profiles']).is_a?(Array)
+          @profiles = value
+        end
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/supported_language_response.rb

@@ -0,0 +1,54 @@
+module TranslationApiClient
+  # 
+  class SupportedLanguageResponse < BaseObject
+    attr_accessor :warning, :error, :language_pairs
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Warning at request level
+        :'warning' => :'warning',
+        
+        # Error at request level
+        :'error' => :'error',
+        
+        # Array of language pairs
+        :'language_pairs' => :'languagePairs'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'warning' => :'string',
+        :'error' => :'string',
+        :'language_pairs' => :'array[LanguagePair]'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'warning']
+        @warning = attributes[:'warning']
+      end
+      
+      if attributes[:'error']
+        @error = attributes[:'error']
+      end
+      
+      if attributes[:'languagePairs']
+        if (value = attributes[:'languagePairs']).is_a?(Array)
+          @language_pairs = value
+        end
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/translation_cancel.rb

@@ -0,0 +1,36 @@
+module TranslationApiClient
+  # 
+  class TranslationCancel < BaseObject
+    attr_accessor :error
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Error of the request
+        :'error' => :'error'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'error' => :'string'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'error']
+        @error = attributes[:'error']
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/translation_output.rb

@@ -0,0 +1,84 @@
+module TranslationApiClient
+  # 
+  class TranslationOutput < BaseObject
+    attr_accessor :warning, :error, :detected_language, :detected_language_confidence, :output, :back_translation, :source
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Warning at output level
+        :'warning' => :'warning',
+        
+        # Error at output level
+        :'error' => :'error',
+        
+        # Result of the automatic language detection if `auto` was specified as source language
+        :'detected_language' => :'detectedLanguage',
+        
+        # Automatic language detection confidence
+        :'detected_language_confidence' => :'detectedLanguageConfidence',
+        
+        # Translated text
+        :'output' => :'output',
+        
+        # Retranslation of output in source language, if backTranslation was specified
+        :'back_translation' => :'backTranslation',
+        
+        # Source text, if withSource was specified
+        :'source' => :'source'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'warning' => :'string',
+        :'error' => :'string',
+        :'detected_language' => :'string',
+        :'detected_language_confidence' => :'double',
+        :'output' => :'string',
+        :'back_translation' => :'string',
+        :'source' => :'string'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'warning']
+        @warning = attributes[:'warning']
+      end
+      
+      if attributes[:'error']
+        @error = attributes[:'error']
+      end
+      
+      if attributes[:'detectedLanguage']
+        @detected_language = attributes[:'detectedLanguage']
+      end
+      
+      if attributes[:'detectedLanguageConfidence']
+        @detected_language_confidence = attributes[:'detectedLanguageConfidence']
+      end
+      
+      if attributes[:'output']
+        @output = attributes[:'output']
+      end
+      
+      if attributes[:'backTranslation']
+        @back_translation = attributes[:'backTranslation']
+      end
+      
+      if attributes[:'source']
+        @source = attributes[:'source']
+      end
+      
+    end
+  end
+end