VimUnDo@8|t(|TнVU'^aIi_aIh=begin #Patch API V14#The core API used to integrate with Patch's service'The version of the OpenAPI document: v1 Contact: developers@usepatch.com,Generated by: https://openapi-generator.tech OpenAPI Generator version: 4.3.1=endrequire 'date' module Patch% class CreateEthereumEstimateRequest attr_accessor :timestamp attr_accessor :gas_used- attr_accessor :transaction_value_eth_gwei attr_accessor :project_id attr_accessor :create_orderB # Attribute mapping from ruby-style variable name to JSON key. def self.attribute_map {% :'timestamp' => :'timestamp',# :'gas_used' => :'gas_used',G :'transaction_value_eth_gwei' => :'transaction_value_eth_gwei',' :'project_id' => :'project_id',* :'create_order' => :'create_order' } end # Attribute type mapping. def self.openapi_types {" :'timestamp' => :'String'," :'gas_used' => :'Integer',4 :'transaction_value_eth_gwei' => :'Integer',# :'project_id' => :'String',% :'create_order' => :'Boolean' } end# # Set with nullable attributes. def self.openapi_nullable# nullable_properties = Set.new* nullable_properties.add("timestamp")) nullable_properties.add("gas_used"); nullable_properties.add("transaction_value_eth_gwei")+ nullable_properties.add("project_id")- nullable_properties.add("create_order") nullable_properties endb # Allows models with corresponding API classes to delegate API operations to those API classesN # Exposes Model.operation_id which delegates to ModelsApi.new.operation_idD # Eg. Order.create_order delegates to OrdersApi.new.create_order3 def self.method_missing(message, *args, &block) if Object.const_defined?('Patch::CreateEthereumEstimateRequestsApi::OPERATIONS') && Patch::CreateEthereumEstimateRequestsApi::OPERATIONS.include?(message)I Patch::CreateEthereumEstimateRequestsApi.new.send(message, *args) else super end end # Initializes the objectC # @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 `Patch::CreateEthereumEstimateRequest` initialize method" endV # check to see if the attribute exists and convert string to symbol for hash key@ attributes = attributes.each_with_object({}) { |(k, v), h|5 if (!self.class.attribute_map.key?(k.to_sym)) fail ArgumentError, "`#{k}` is not a valid attribute in `Patch::CreateEthereumEstimateRequest`. 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?(:'timestamp')1 self.timestamp = attributes[:'timestamp'] end% if attributes.key?(:'gas_used')/ self.gas_used = attributes[:'gas_used'] end7 if attributes.key?(:'transaction_value_eth_gwei')S self.transaction_value_eth_gwei = attributes[:'transaction_value_eth_gwei'] end' if attributes.key?(:'project_id')3 self.project_id = attributes[:'project_id'] end) if attributes.key?(:'create_order')7 self.create_order = attributes[:'create_order'] end endQ # Show invalid properties with the reasons. Usually used together with valid?9 # @return Array for valid properties with the reasons def list_invalid_properties$ invalid_properties = Array.new invalid_properties endC # Check to see if the all the properties in the model are valid( # @return true if the model is valid def valid? true end2 # Checks equality by comparing each attribute.+ # @param [Object] Object to be compared def ==(o)# return true if self.equal?(o) self.class == o.class &&% timestamp == o.timestamp &&# gas_used == o.gas_used &&G transaction_value_eth_gwei == o.transaction_value_eth_gwei &&' project_id == o.project_id &&( create_order == o.create_order end # @see the `==` method+ # @param [Object] Object to be compared def eql?(o) self == o end7 # Calculates hash code according to all attributes.! # @return [Integer] Hash code def hashV [timestamp, gas_used, transaction_value_eth_gwei, project_id, create_order].hash end! # Builds the object from hashC # @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 hashC # @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)7 self.class.openapi_types.each_pair do |key, type|# if type =~ /\AArray<(.*)>/iJ # check to ensure the input is an array given that the attribute: # is documented as an array but the input is notC if attributes[self.class.attribute_map[key]].is_a?(Array)k 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]]))b 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 type2 # @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 :Boolean0 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<(?.+)>\z/3 inner_type = Regexp.last_match[:inner_type]5 value.map { |v| _deserialize(inner_type, v) }4 when /\AHash<(?.+?), (?.+)>\z/+ k_type = Regexp.last_match[:k_type]+ v_type = Regexp.last_match[:v_type] {}.tap do |hash| value.each do |k, v|C hash[_deserialize(k_type, k)] = _deserialize(v_type, v) end end else # model4 Patch.const_get(type).build_from_hash(value) end end5 # Returns the string representation of the object8 # @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 = {}9 self.class.attribute_map.each_pair do |attr, param| value = self.send(attr) if value.nil?B 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 end1 # 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|5 value.each { |k, v| hash[k] = _to_hash(v) } end& elsif value.respond_to? :to_hash value.to_hash else value end end endend5