hubspot-api-client 9.0.0 → 9.2.0

data/lib/hubspot/codegen/cms/blogs/blog-posts/models/layout_section.rb

@@ -0,0 +1,391 @@
+=begin
+#Blog Post endpoints
+
+#\"Use these endpoints for interacting with Blog Posts, Blog Authors, and Blog Tags\"
+
+The version of the OpenAPI document: v3
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 4.3.1
+
+=end
+
+require 'date'
+
+module Hubspot
+  module Cms
+    module Blogs
+      module BlogPosts
+        class LayoutSection
+          attr_accessor :x
+
+          attr_accessor :w
+
+          attr_accessor :name
+
+          attr_accessor :label
+
+          attr_accessor :type
+
+          attr_accessor :params
+
+          attr_accessor :rows
+
+          attr_accessor :row_meta_data
+
+          attr_accessor :cells
+
+          attr_accessor :css_class
+
+          attr_accessor :css_style
+
+          attr_accessor :css_id
+
+          attr_accessor :styles
+
+          # Attribute mapping from ruby-style variable name to JSON key.
+          def self.attribute_map
+            {
+              :'x' => :'x',
+              :'w' => :'w',
+              :'name' => :'name',
+              :'label' => :'label',
+              :'type' => :'type',
+              :'params' => :'params',
+              :'rows' => :'rows',
+              :'row_meta_data' => :'rowMetaData',
+              :'cells' => :'cells',
+              :'css_class' => :'cssClass',
+              :'css_style' => :'cssStyle',
+              :'css_id' => :'cssId',
+              :'styles' => :'styles'
+            }
+          end
+
+          # Attribute type mapping.
+          def self.openapi_types
+            {
+              :'x' => :'Integer',
+              :'w' => :'Integer',
+              :'name' => :'String',
+              :'label' => :'String',
+              :'type' => :'String',
+              :'params' => :'Object',
+              :'rows' => :'Array<Hash<String, LayoutSection>>',
+              :'row_meta_data' => :'Array<RowMetaData>',
+              :'cells' => :'Array<LayoutSection>',
+              :'css_class' => :'String',
+              :'css_style' => :'String',
+              :'css_id' => :'String',
+              :'styles' => :'Styles'
+            }
+          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::Blogs::BlogPosts::LayoutSection` 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::Blogs::BlogPosts::LayoutSection`. 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?(:'x')
+              self.x = attributes[:'x']
+            end
+
+            if attributes.key?(:'w')
+              self.w = attributes[:'w']
+            end
+
+            if attributes.key?(:'name')
+              self.name = attributes[:'name']
+            end
+
+            if attributes.key?(:'label')
+              self.label = attributes[:'label']
+            end
+
+            if attributes.key?(:'type')
+              self.type = attributes[:'type']
+            end
+
+            if attributes.key?(:'params')
+              self.params = attributes[:'params']
+            end
+
+            if attributes.key?(:'rows')
+              if (value = attributes[:'rows']).is_a?(Array)
+                self.rows = value
+              end
+            end
+
+            if attributes.key?(:'row_meta_data')
+              if (value = attributes[:'row_meta_data']).is_a?(Array)
+                self.row_meta_data = value
+              end
+            end
+
+            if attributes.key?(:'cells')
+              if (value = attributes[:'cells']).is_a?(Array)
+                self.cells = value
+              end
+            end
+
+            if attributes.key?(:'css_class')
+              self.css_class = attributes[:'css_class']
+            end
+
+            if attributes.key?(:'css_style')
+              self.css_style = attributes[:'css_style']
+            end
+
+            if attributes.key?(:'css_id')
+              self.css_id = attributes[:'css_id']
+            end
+
+            if attributes.key?(:'styles')
+              self.styles = attributes[:'styles']
+            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 @x.nil?
+              invalid_properties.push('invalid value for "x", x cannot be nil.')
+            end
+
+            if @w.nil?
+              invalid_properties.push('invalid value for "w", w cannot be nil.')
+            end
+
+            if @name.nil?
+              invalid_properties.push('invalid value for "name", name cannot be nil.')
+            end
+
+            if @label.nil?
+              invalid_properties.push('invalid value for "label", label cannot be nil.')
+            end
+
+            if @type.nil?
+              invalid_properties.push('invalid value for "type", type cannot be nil.')
+            end
+
+            if @params.nil?
+              invalid_properties.push('invalid value for "params", params cannot be nil.')
+            end
+
+            if @rows.nil?
+              invalid_properties.push('invalid value for "rows", rows cannot be nil.')
+            end
+
+            if @row_meta_data.nil?
+              invalid_properties.push('invalid value for "row_meta_data", row_meta_data cannot be nil.')
+            end
+
+            if @cells.nil?
+              invalid_properties.push('invalid value for "cells", cells cannot be nil.')
+            end
+
+            if @css_class.nil?
+              invalid_properties.push('invalid value for "css_class", css_class cannot be nil.')
+            end
+
+            if @css_style.nil?
+              invalid_properties.push('invalid value for "css_style", css_style cannot be nil.')
+            end
+
+            if @css_id.nil?
+              invalid_properties.push('invalid value for "css_id", css_id cannot be nil.')
+            end
+
+            if @styles.nil?
+              invalid_properties.push('invalid value for "styles", styles 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 @x.nil?
+            return false if @w.nil?
+            return false if @name.nil?
+            return false if @label.nil?
+            return false if @type.nil?
+            return false if @params.nil?
+            return false if @rows.nil?
+            return false if @row_meta_data.nil?
+            return false if @cells.nil?
+            return false if @css_class.nil?
+            return false if @css_style.nil?
+            return false if @css_id.nil?
+            return false if @styles.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 &&
+                x == o.x &&
+                w == o.w &&
+                name == o.name &&
+                label == o.label &&
+                type == o.type &&
+                params == o.params &&
+                rows == o.rows &&
+                row_meta_data == o.row_meta_data &&
+                cells == o.cells &&
+                css_class == o.css_class &&
+                css_style == o.css_style &&
+                css_id == o.css_id &&
+                styles == o.styles
+          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
+            [x, w, name, label, type, params, rows, row_meta_data, cells, css_class, css_style, css_id, styles].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)
+            self.class.openapi_types.each_pair do |key, type|
+              if 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 # or else data not found in attributes(hash), not an issue as the data can be optional
+            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 :DateTime
+              DateTime.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
+              Hubspot::Cms::Blogs::BlogPosts.const_get(type).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
+end

data/lib/hubspot/codegen/cms/blogs/blog-posts/models/next_page.rb

@@ -0,0 +1,226 @@
+=begin
+#Blog Post endpoints
+
+#\"Use these endpoints for interacting with Blog Posts, Blog Authors, and Blog Tags\"
+
+The version of the OpenAPI document: v3
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 4.3.1
+
+=end
+
+require 'date'
+
+module Hubspot
+  module Cms
+    module Blogs
+      module BlogPosts
+        class NextPage
+          attr_accessor :after
+
+          attr_accessor :link
+
+          # Attribute mapping from ruby-style variable name to JSON key.
+          def self.attribute_map
+            {
+              :'after' => :'after',
+              :'link' => :'link'
+            }
+          end
+
+          # Attribute type mapping.
+          def self.openapi_types
+            {
+              :'after' => :'String',
+              :'link' => :'String'
+            }
+          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::Blogs::BlogPosts::NextPage` 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::Blogs::BlogPosts::NextPage`. 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?(:'after')
+              self.after = attributes[:'after']
+            end
+
+            if attributes.key?(:'link')
+              self.link = attributes[:'link']
+            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 @after.nil?
+              invalid_properties.push('invalid value for "after", after 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 @after.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 &&
+                after == o.after &&
+                link == o.link
+          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
+            [after, link].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)
+            self.class.openapi_types.each_pair do |key, type|
+              if 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 # or else data not found in attributes(hash), not an issue as the data can be optional
+            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 :DateTime
+              DateTime.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
+              Hubspot::Cms::Blogs::BlogPosts.const_get(type).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
+end