{{#description}}  # {{{description}}}{{/description}}
  class {{classname}}{{#vars}}{{#description}}
    # {{{description}}}{{/description}}
    attr_accessor :{{{name}}}
  {{/vars}}

{{#hasEnums}}
    class EnumAttributeValidator
      attr_reader :datatype
      attr_reader :allowable_values

      def initialize(datatype, allowable_values)
        @allowable_values = allowable_values.map do |value|
          case datatype.to_s
          when /Integer/i
            value.to_i
          when /Float/i
            value.to_f
          else
            value
          end
        end
      end

      def valid?(value)
        !value || allowable_values.include?(value)
      end
    end
{{/hasEnums}}

    # Attribute mapping from ruby-style variable name to JSON key.
    def self.attribute_map
      {
        {{#vars}}
        :'{{{name}}}' => :'{{{baseName}}}'{{#hasMore}},{{/hasMore}}
        {{/vars}}
      }
    end

    # Attribute type mapping.
    def self.swagger_types
      {
        {{#vars}}
        :'{{{name}}}' => :'{{{datatype}}}'{{#hasMore}},{{/hasMore}}
        {{/vars}}
      }
    end

    # Initializes the object
    # @param [Hash] attributes Model attributes in the form of hash
    def initialize(attributes = {})
      return unless attributes.is_a?(Hash)

      # convert string to symbol for hash key
      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}

      {{#vars}}
      if attributes.has_key?(:'{{{baseName}}}')
        {{#isContainer}}
        if (value = attributes[:'{{{baseName}}}']).is_a?(Array)
          self.{{{name}}} = value
        end
        {{/isContainer}}
        {{^isContainer}}
        self.{{{name}}} = attributes[:'{{{baseName}}}']
        {{/isContainer}}
      {{#defaultValue}}
      else
        self.{{{name}}} = {{{defaultValue}}}
      {{/defaultValue}}
      end

      {{/vars}}
    end

    # Show invalid properties with the reasons. Usually used together with valid?
    # @return Array for valid properies with the reasons
    def list_invalid_properties
      invalid_properties = Array.new
      {{#hasValidation}}
      if @{{{name}}}.nil?
        fail ArgumentError, "{{{name}}} cannot be nil"
      end

      {{#minLength}}
      if @{{{name}}}.to_s.length > {{{maxLength}}}
        invalid_properties.push("invalid value for '{{{name}}}', the character length must be smaller than or equal to {{{maxLength}}}.")
      end

      {{/minLength}}
      {{#maxLength}}
      if @{{{name}}}.to_s.length < {{{minLength}}}
        invalid_properties.push("invalid value for '{{{name}}}', the character length must be great than or equal to {{{minLength}}}.")
      end

      {{/maxLength}}
      {{#maximum}}
      if @{{{name}}} > {{{maximum}}}
        invalid_properties.push("invalid value for '{{{name}}}', must be smaller than or equal to {{{maximum}}}.")
      end

      {{/maximum}}
      {{#minimum}}
      if @{{{name}}} < {{{minimum}}}
        invalid_properties.push("invalid value for '{{{name}}}', must be greater than or equal to {{{minimum}}}.")
      end

      {{/minimum}}
      {{#pattern}}
      if @{{{name}}} !~ Regexp.new({{{pattern}}})
        invalid_properties.push("invalid value for '{{{name}}}', must conform to the pattern {{{pattern}}}.")
      end

      {{/pattern}}
      {{/hasValidation}}
      return invalid_properties
    end

    # Check to see if the all the properties in the model are valid
    # @return true if the model is valid
    def valid?
      {{#vars}}
      {{#required}}
      return false if @{{{name}}}.nil?
      {{/required}}
      {{#isEnum}}
      {{^isContainer}}
      {{{name}}}_validator = EnumAttributeValidator.new('{{{datatype}}}', [{{#allowableValues}}{{#values}}"{{{this}}}"{{^-last}}, {{/-last}}{{/values}}{{/allowableValues}}])
      return false unless {{{name}}}_validator.valid?(@{{{name}}})
      {{/isContainer}}
      {{/isEnum}}
      {{#hasValidation}}
      {{#minLength}}
      return false if @{{{name}}}.to_s.length > {{{maxLength}}}
      {{/minLength}}
      {{#maxLength}}
      return false if @{{{name}}}.to_s.length < {{{minLength}}}
      {{/maxLength}}
      {{#maximum}}
      return false if @{{{name}}} > {{{maximum}}}
      {{/maximum}}
      {{#minimum}}
      return false if @{{{name}}} < {{{minimum}}}
      {{/minimum}}
      {{#pattern}}
      return false if @{{{name}}} !~ Regexp.new({{{pattern}}})
      {{/pattern}}
      {{/hasValidation}}
      {{/vars}}
      return true
    end

    {{#vars}}
    {{#isEnum}}
    {{^isContainer}}
    # Custom attribute writer method checking allowed values (enum).
    # @param [Object] {{{name}}} Object to be assigned
    def {{{name}}}=({{{name}}})
      validator = EnumAttributeValidator.new('{{{datatype}}}', [{{#allowableValues}}{{#values}}"{{{this}}}"{{^-last}}, {{/-last}}{{/values}}{{/allowableValues}}])
      unless validator.valid?({{{name}}})
        fail ArgumentError, "invalid value for '{{{name}}}', must be one of #{validator.allowable_values}."
      end
      @{{{name}}} = {{{name}}}
    end

    {{/isContainer}}
    {{/isEnum}}
    {{^isEnum}}
    {{#hasValidation}}
    # Custom attribute writer method with validation
    # @param [Object] {{{name}}} Value to be assigned
    def {{{name}}}=({{{name}}})
      if {{{name}}}.nil?
        fail ArgumentError, "{{{name}}} cannot be nil"
      end

      {{#minLength}}
      if {{{name}}}.to_s.length > {{{maxLength}}}
        fail ArgumentError, "invalid value for '{{{name}}}', the character length must be smaller than or equal to {{{maxLength}}}."
      end

      {{/minLength}}
      {{#maxLength}}
      if {{{name}}}.to_s.length < {{{minLength}}}
        fail ArgumentError, "invalid value for '{{{name}}}', the character length must be great than or equal to {{{minLength}}}."
      end

      {{/maxLength}}
      {{#maximum}}
      if {{{name}}} > {{{maximum}}}
        fail ArgumentError, "invalid value for '{{{name}}}', must be smaller than or equal to {{{maximum}}}."
      end

      {{/maximum}}
      {{#minimum}}
      if {{{name}}} < {{{minimum}}}
        fail ArgumentError, "invalid value for '{{{name}}}', must be greater than or equal to {{{minimum}}}."
      end

      {{/minimum}}
      {{#pattern}}
      if @{{{name}}} !~ Regexp.new({{{pattern}}})
        fail ArgumentError, "invalid value for '{{{name}}}', must conform to the pattern {{{pattern}}}."
      end

      {{/pattern}}
      @{{{name}}} = {{{name}}}
    end

    {{/hasValidation}}
    {{/isEnum}}
    {{/vars}}
    # Checks equality by comparing each attribute.
    # @param [Object] Object to be compared
    def ==(o)
      return true if self.equal?(o)
      self.class == o.class{{#vars}} &&
          {{name}} == o.{{name}}{{/vars}}
    end

    # @see the `==` method
    # @param [Object] Object to be compared
    def eql?(o)
      self == o
    end

    # Calculates hash code according to all attributes.
    # @return [Fixnum] Hash code
    def hash
      [{{#vars}}{{name}}{{#hasMore}}, {{/hasMore}}{{/vars}}].hash
    end

{{> base_object}}
  end
