=begin
#Hubdb

#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

The version of the OpenAPI document: v3

Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.2.1

=end

require 'date'
require 'time'

module Hubspot
  module Cms
    module Hubdb
      class HubDbTableV3
        # Specifies the key value pairs of the [metadata fields](https://developers.hubspot.com/docs/cms/guides/dynamic-pages/hubdb#dynamic-pages) with the associated column IDs.
        attr_accessor :dynamic_meta_tags

        attr_accessor :updated_by

        # Specifies whether the table can be read by public without authorization
        attr_accessor :allow_public_api_access

        # Specifies whether the table can be used for creation of dynamic pages
        attr_accessor :use_for_pages

        # Timestamp at which the table is published recently
        attr_accessor :published_at

        # List of columns in the table
        attr_accessor :columns

        # Label of the table
        attr_accessor :label

        attr_accessor :published

        # Number of columns including deleted
        attr_accessor :column_count

        # Specifies whether child tables can be created
        attr_accessor :allow_child_tables

        # Timestamp at which the table is created
        attr_accessor :created_at

        attr_accessor :deleted

        attr_accessor :created_by

        # Name of the table
        attr_accessor :name

        # Specifies creation of multi-level dynamic pages using child tables
        attr_accessor :enable_child_table_pages

        # Id of the table
        attr_accessor :id

        # Number of rows in the table
        attr_accessor :row_count

        attr_accessor :is_ordered_manually

        # Timestamp at which the table is updated recently
        attr_accessor :updated_at

        # Attribute mapping from ruby-style variable name to JSON key.
        def self.attribute_map
          {
            :'dynamic_meta_tags' => :'dynamicMetaTags',
            :'updated_by' => :'updatedBy',
            :'allow_public_api_access' => :'allowPublicApiAccess',
            :'use_for_pages' => :'useForPages',
            :'published_at' => :'publishedAt',
            :'columns' => :'columns',
            :'label' => :'label',
            :'published' => :'published',
            :'column_count' => :'columnCount',
            :'allow_child_tables' => :'allowChildTables',
            :'created_at' => :'createdAt',
            :'deleted' => :'deleted',
            :'created_by' => :'createdBy',
            :'name' => :'name',
            :'enable_child_table_pages' => :'enableChildTablePages',
            :'id' => :'id',
            :'row_count' => :'rowCount',
            :'is_ordered_manually' => :'isOrderedManually',
            :'updated_at' => :'updatedAt'
          }
        end

        # Returns all the JSON keys this model knows about
        def self.acceptable_attributes
          attribute_map.values
        end

        # Attribute type mapping.
        def self.openapi_types
          {
            :'dynamic_meta_tags' => :'Hash<String, Integer>',
            :'updated_by' => :'SimpleUser',
            :'allow_public_api_access' => :'Boolean',
            :'use_for_pages' => :'Boolean',
            :'published_at' => :'Time',
            :'columns' => :'Array<Column>',
            :'label' => :'String',
            :'published' => :'Boolean',
            :'column_count' => :'Integer',
            :'allow_child_tables' => :'Boolean',
            :'created_at' => :'Time',
            :'deleted' => :'Boolean',
            :'created_by' => :'SimpleUser',
            :'name' => :'String',
            :'enable_child_table_pages' => :'Boolean',
            :'id' => :'String',
            :'row_count' => :'Integer',
            :'is_ordered_manually' => :'Boolean',
            :'updated_at' => :'Time'
          }
        end

        # List of attributes with nullable: true
        def self.openapi_nullable
          Set.new([
          ])
        end

        # Initializes the object
        # @param [Hash] attributes Model attributes in the form of hash
        def initialize(attributes = {})
          if (!attributes.is_a?(Hash))
            fail ArgumentError, "The input argument (attributes) must be a hash in `Hubspot::Cms::Hubdb::HubDbTableV3` initialize method"
          end

          # check to see if the attribute exists and convert string to symbol for hash key
          attributes = attributes.each_with_object({}) { |(k, v), h|
            if (!self.class.attribute_map.key?(k.to_sym))
              fail ArgumentError, "`#{k}` is not a valid attribute in `Hubspot::Cms::Hubdb::HubDbTableV3`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
            end
            h[k.to_sym] = v
          }

          if attributes.key?(:'dynamic_meta_tags')
            if (value = attributes[:'dynamic_meta_tags']).is_a?(Hash)
              self.dynamic_meta_tags = value
            end
          end

          if attributes.key?(:'updated_by')
            self.updated_by = attributes[:'updated_by']
          end

          if attributes.key?(:'allow_public_api_access')
            self.allow_public_api_access = attributes[:'allow_public_api_access']
          end

          if attributes.key?(:'use_for_pages')
            self.use_for_pages = attributes[:'use_for_pages']
          end

          if attributes.key?(:'published_at')
            self.published_at = attributes[:'published_at']
          end

          if attributes.key?(:'columns')
            if (value = attributes[:'columns']).is_a?(Array)
              self.columns = value
            end
          end

          if attributes.key?(:'label')
            self.label = attributes[:'label']
          end

          if attributes.key?(:'published')
            self.published = attributes[:'published']
          end

          if attributes.key?(:'column_count')
            self.column_count = attributes[:'column_count']
          end

          if attributes.key?(:'allow_child_tables')
            self.allow_child_tables = attributes[:'allow_child_tables']
          end

          if attributes.key?(:'created_at')
            self.created_at = attributes[:'created_at']
          end

          if attributes.key?(:'deleted')
            self.deleted = attributes[:'deleted']
          end

          if attributes.key?(:'created_by')
            self.created_by = attributes[:'created_by']
          end

          if attributes.key?(:'name')
            self.name = attributes[:'name']
          end

          if attributes.key?(:'enable_child_table_pages')
            self.enable_child_table_pages = attributes[:'enable_child_table_pages']
          end

          if attributes.key?(:'id')
            self.id = attributes[:'id']
          end

          if attributes.key?(:'row_count')
            self.row_count = attributes[:'row_count']
          end

          if attributes.key?(:'is_ordered_manually')
            self.is_ordered_manually = attributes[:'is_ordered_manually']
          end

          if attributes.key?(:'updated_at')
            self.updated_at = attributes[:'updated_at']
          end
        end

        # Show invalid properties with the reasons. Usually used together with valid?
        # @return Array for valid properties with the reasons
        def list_invalid_properties
          invalid_properties = Array.new
          if @label.nil?
            invalid_properties.push('invalid value for "label", label cannot be nil.')
          end

          if @name.nil?
            invalid_properties.push('invalid value for "name", name cannot be nil.')
          end

          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?
          return false if @label.nil?
          return false if @name.nil?
          true
        end

        # Checks equality by comparing each attribute.
        # @param [Object] Object to be compared
        def ==(o)
          return true if self.equal?(o)
          self.class == o.class &&
              dynamic_meta_tags == o.dynamic_meta_tags &&
              updated_by == o.updated_by &&
              allow_public_api_access == o.allow_public_api_access &&
              use_for_pages == o.use_for_pages &&
              published_at == o.published_at &&
              columns == o.columns &&
              label == o.label &&
              published == o.published &&
              column_count == o.column_count &&
              allow_child_tables == o.allow_child_tables &&
              created_at == o.created_at &&
              deleted == o.deleted &&
              created_by == o.created_by &&
              name == o.name &&
              enable_child_table_pages == o.enable_child_table_pages &&
              id == o.id &&
              row_count == o.row_count &&
              is_ordered_manually == o.is_ordered_manually &&
              updated_at == o.updated_at
        end

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

        # Calculates hash code according to all attributes.
        # @return [Integer] Hash code
        def hash
          [dynamic_meta_tags, updated_by, allow_public_api_access, use_for_pages, published_at, columns, label, published, column_count, allow_child_tables, created_at, deleted, created_by, name, enable_child_table_pages, id, row_count, is_ordered_manually, updated_at].hash
        end

        # Builds the object from hash
        # @param [Hash] attributes Model attributes in the form of hash
        # @return [Object] Returns the model itself
        def self.build_from_hash(attributes)
          new.build_from_hash(attributes)
        end

        # Builds the object from hash
        # @param [Hash] attributes Model attributes in the form of hash
        # @return [Object] Returns the model itself
        def build_from_hash(attributes)
          return nil unless attributes.is_a?(Hash)
          attributes = attributes.transform_keys(&:to_sym)
          self.class.openapi_types.each_pair do |key, type|
            if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
              self.send("#{key}=", nil)
            elsif type =~ /\AArray<(.*)>/i
              # check to ensure the input is an array given that the attribute
              # is documented as an array but the input is not
              if attributes[self.class.attribute_map[key]].is_a?(Array)
                self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
              end
            elsif !attributes[self.class.attribute_map[key]].nil?
              self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
            end
          end

          self
        end

        # Deserializes the data based on type
        # @param string type Data type
        # @param string value Value to be deserialized
        # @return [Object] Deserialized data
        def _deserialize(type, value)
          case type.to_sym
          when :Time
            Time.parse(value)
          when :Date
            Date.parse(value)
          when :String
            value.to_s
          when :Integer
            value.to_i
          when :Float
            value.to_f
          when :Boolean
            if value.to_s =~ /\A(true|t|yes|y|1)\z/i
              true
            else
              false
            end
          when :Object
            # generic object (usually a Hash), return directly
            value
          when /\AArray<(?<inner_type>.+)>\z/
            inner_type = Regexp.last_match[:inner_type]
            value.map { |v| _deserialize(inner_type, v) }
          when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
            k_type = Regexp.last_match[:k_type]
            v_type = Regexp.last_match[:v_type]
            {}.tap do |hash|
              value.each do |k, v|
                hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
              end
            end
          else # model
            # models (e.g. Pet) or oneOf
            klass = Hubspot::Cms::Hubdb.const_get(type)
            klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
          end
        end

        # Returns the string representation of the object
        # @return [String] String presentation of the object
        def to_s
          to_hash.to_s
        end

        # to_body is an alias to to_hash (backward compatibility)
        # @return [Hash] Returns the object in the form of hash
        def to_body
          to_hash
        end

        # Returns the object in the form of hash
        # @return [Hash] Returns the object in the form of hash
        def to_hash
          hash = {}
          self.class.attribute_map.each_pair do |attr, param|
            value = self.send(attr)
            if value.nil?
              is_nullable = self.class.openapi_nullable.include?(attr)
              next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
            end

            hash[param] = _to_hash(value)
          end
          hash
        end

        # Outputs non-array value in the form of hash
        # For object, use to_hash. Otherwise, just return the value
        # @param [Object] value Any valid value
        # @return [Hash] Returns the value in the form of hash
        def _to_hash(value)
          if value.is_a?(Array)
            value.compact.map { |v| _to_hash(v) }
          elsif value.is_a?(Hash)
            {}.tap do |hash|
              value.each { |k, v| hash[k] = _to_hash(v) }
            end
          elsif value.respond_to? :to_hash
            value.to_hash
          else
            value
          end
        end

      end

    end
  end
end
