temper-rb 0.6.2 → 0.6.3

data/lib/temper/generated/models/ask_response.rb

@@ -0,0 +1,312 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.6.3
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # One page of the artifacts matching an ask, in `(created, artifact_id)` order, oldest first.
+  class AskResponse < ApiModelBase
+    # The version of the shape's lineage now in force, when the version this enumeration was validated against has been amended since its first page; `null` otherwise. A continuation is validated against the version the first page named, but each row's `shape_state`, and any `shape_states` narrowing, are read against the version now in force, whose verdicts reconciliation may not yet have written. So an ask narrowed by `shape_states` should start again from a first page, asking the version `amended_since` names, when it appears.
+    attr_accessor :amended_since
+
+    # The matching artifacts that fit this page's byte budget and depth, each whole: `content` is the stored content, absent for an artifact committed with no bytes. `resource_id` is attribution, not a set.
+    attr_accessor :artifacts
+
+    # Where to continue, or `null` when the enumeration is over. Pass it back unchanged as the next request's `after`, with the same ask. Only `null` ends an enumeration: a page also stops when it has read as much as one page may read, and then `next` is the last artifact it read, matched or not, so a page can carry no artifacts and still a `next`.
+    attr_accessor :_next
+
+    # The order rows arrive in. Enumeration order, never rank.
+    attr_accessor :ordered_by
+
+    # Matching artifacts too large for any page's byte budget, or too deeply nested for a page (content more than 96 arrays or objects deep), in order among the rest, by id and size and without content. Each is read whole by id (`GET /api/data-artifacts/{artifact_id}`); on the hosted deployment that read is refused too when the response carrying the artifact, with its content as storage serves it, is longer than the platform's response cap (see `OversizedArtifact`).
+    attr_accessor :oversized
+
+    # What the ask counted over its whole population, on the first page; `null` on every later page. These are exact counts over the whole counted set: to count them, the first page matches every governed artifact of the home, content included, and the read budget that bounds the page's own rows does not bound that. They are read in a statement of their own beside the page's, so a commit landing between the two can make `matched` differ from the rows by that commit; they describe the population, not the page.
+    attr_accessor :population
+
+    # The shape version this page was validated against: on the first page the version the ask named, and on every later page that same version, even once amended (see `amended_since`).
+    attr_accessor :shape
+
+    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
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'amended_since' => :'amended_since',
+        :'artifacts' => :'artifacts',
+        :'_next' => :'next',
+        :'ordered_by' => :'ordered_by',
+        :'oversized' => :'oversized',
+        :'population' => :'population',
+        :'shape' => :'shape'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'amended_since' => :'ShapeSuccessor',
+        :'artifacts' => :'Array<ArtifactView>',
+        :'_next' => :'ArtifactCursor',
+        :'ordered_by' => :'AskOrder',
+        :'oversized' => :'Array<OversizedArtifact>',
+        :'population' => :'ArtifactAskPopulation',
+        :'shape' => :'AskedShape'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'amended_since',
+        :'_next',
+        :'population',
+      ])
+    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 `Temper::Generated::AskResponse` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Temper::Generated::AskResponse`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'amended_since')
+        self.amended_since = attributes[:'amended_since']
+      else
+        self.amended_since = nil
+      end
+
+      if attributes.key?(:'artifacts')
+        if (value = attributes[:'artifacts']).is_a?(Array)
+          self.artifacts = value
+        end
+      else
+        self.artifacts = nil
+      end
+
+      if attributes.key?(:'_next')
+        self._next = attributes[:'_next']
+      else
+        self._next = nil
+      end
+
+      if attributes.key?(:'ordered_by')
+        self.ordered_by = attributes[:'ordered_by']
+      else
+        self.ordered_by = nil
+      end
+
+      if attributes.key?(:'oversized')
+        if (value = attributes[:'oversized']).is_a?(Array)
+          self.oversized = value
+        end
+      else
+        self.oversized = nil
+      end
+
+      if attributes.key?(:'population')
+        self.population = attributes[:'population']
+      else
+        self.population = nil
+      end
+
+      if attributes.key?(:'shape')
+        self.shape = attributes[:'shape']
+      else
+        self.shape = nil
+      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
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @artifacts.nil?
+        invalid_properties.push('invalid value for "artifacts", artifacts cannot be nil.')
+      end
+
+      if @ordered_by.nil?
+        invalid_properties.push('invalid value for "ordered_by", ordered_by cannot be nil.')
+      end
+
+      if @oversized.nil?
+        invalid_properties.push('invalid value for "oversized", oversized cannot be nil.')
+      end
+
+      if @shape.nil?
+        invalid_properties.push('invalid value for "shape", shape 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?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @artifacts.nil?
+      return false if @ordered_by.nil?
+      return false if @oversized.nil?
+      return false if @shape.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] artifacts Value to be assigned
+    def artifacts=(artifacts)
+      if artifacts.nil?
+        fail ArgumentError, 'artifacts cannot be nil'
+      end
+
+      @artifacts = artifacts
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] ordered_by Value to be assigned
+    def ordered_by=(ordered_by)
+      if ordered_by.nil?
+        fail ArgumentError, 'ordered_by cannot be nil'
+      end
+
+      @ordered_by = ordered_by
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] oversized Value to be assigned
+    def oversized=(oversized)
+      if oversized.nil?
+        fail ArgumentError, 'oversized cannot be nil'
+      end
+
+      @oversized = oversized
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] shape Value to be assigned
+    def shape=(shape)
+      if shape.nil?
+        fail ArgumentError, 'shape cannot be nil'
+      end
+
+      @shape = shape
+    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 &&
+          amended_since == o.amended_since &&
+          artifacts == o.artifacts &&
+          _next == o._next &&
+          ordered_by == o.ordered_by &&
+          oversized == o.oversized &&
+          population == o.population &&
+          shape == o.shape
+    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
+      [amended_since, artifacts, _next, ordered_by, oversized, population, shape].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)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{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[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_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
+
+  end
+
+end

data/lib/temper/generated/models/askable_path.rb

@@ -0,0 +1,221 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.6.3
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # One askable path: its segments, what the schema declares there, and the operators feasible at it (spec §2.5).
+  class AskablePath < ApiModelBase
+    attr_accessor :facts
+
+    attr_accessor :operators
+
+    attr_accessor :path
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'facts' => :'facts',
+        :'operators' => :'operators',
+        :'path' => :'path'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'facts' => :'PathFacts',
+        :'operators' => :'Array<AskOperator>',
+        :'path' => :'Array<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 `Temper::Generated::AskablePath` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Temper::Generated::AskablePath`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'facts')
+        self.facts = attributes[:'facts']
+      else
+        self.facts = nil
+      end
+
+      if attributes.key?(:'operators')
+        if (value = attributes[:'operators']).is_a?(Array)
+          self.operators = value
+        end
+      else
+        self.operators = nil
+      end
+
+      if attributes.key?(:'path')
+        if (value = attributes[:'path']).is_a?(Array)
+          self.path = value
+        end
+      else
+        self.path = nil
+      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
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @facts.nil?
+        invalid_properties.push('invalid value for "facts", facts cannot be nil.')
+      end
+
+      if @operators.nil?
+        invalid_properties.push('invalid value for "operators", operators cannot be nil.')
+      end
+
+      if @path.nil?
+        invalid_properties.push('invalid value for "path", path 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?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @facts.nil?
+      return false if @operators.nil?
+      return false if @path.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] facts Value to be assigned
+    def facts=(facts)
+      if facts.nil?
+        fail ArgumentError, 'facts cannot be nil'
+      end
+
+      @facts = facts
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] operators Value to be assigned
+    def operators=(operators)
+      if operators.nil?
+        fail ArgumentError, 'operators cannot be nil'
+      end
+
+      @operators = operators
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] path Value to be assigned
+    def path=(path)
+      if path.nil?
+        fail ArgumentError, 'path cannot be nil'
+      end
+
+      @path = path
+    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 &&
+          facts == o.facts &&
+          operators == o.operators &&
+          path == o.path
+    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
+      [facts, operators, path].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)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{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[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_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
+
+  end
+
+end