temper-rb 0.5.1

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

@@ -0,0 +1,295 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.5.1
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # Mint/update a `kb_access_grants` row on a resource. Principal `{kb_teams,kb_profiles}`. The DB coherence CHECK enforces `write|delete|grant ⇒ read`; pass a coherent set (a write grant implies read).
+  class ResourceGrantBody < ApiModelBase
+    attr_accessor :can_delete
+
+    attr_accessor :can_grant
+
+    attr_accessor :can_read
+
+    attr_accessor :can_write
+
+    attr_accessor :principal_id
+
+    attr_accessor :principal_table
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'can_delete' => :'can_delete',
+        :'can_grant' => :'can_grant',
+        :'can_read' => :'can_read',
+        :'can_write' => :'can_write',
+        :'principal_id' => :'principal_id',
+        :'principal_table' => :'principal_table'
+      }
+    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
+      {
+        :'can_delete' => :'Boolean',
+        :'can_grant' => :'Boolean',
+        :'can_read' => :'Boolean',
+        :'can_write' => :'Boolean',
+        :'principal_id' => :'String',
+        :'principal_table' => :'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::ResourceGrantBody` 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::ResourceGrantBody`. 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?(:'can_delete')
+        self.can_delete = attributes[:'can_delete']
+      else
+        self.can_delete = nil
+      end
+
+      if attributes.key?(:'can_grant')
+        self.can_grant = attributes[:'can_grant']
+      else
+        self.can_grant = nil
+      end
+
+      if attributes.key?(:'can_read')
+        self.can_read = attributes[:'can_read']
+      else
+        self.can_read = nil
+      end
+
+      if attributes.key?(:'can_write')
+        self.can_write = attributes[:'can_write']
+      else
+        self.can_write = nil
+      end
+
+      if attributes.key?(:'principal_id')
+        self.principal_id = attributes[:'principal_id']
+      else
+        self.principal_id = nil
+      end
+
+      if attributes.key?(:'principal_table')
+        self.principal_table = attributes[:'principal_table']
+      else
+        self.principal_table = 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 @can_delete.nil?
+        invalid_properties.push('invalid value for "can_delete", can_delete cannot be nil.')
+      end
+
+      if @can_grant.nil?
+        invalid_properties.push('invalid value for "can_grant", can_grant cannot be nil.')
+      end
+
+      if @can_read.nil?
+        invalid_properties.push('invalid value for "can_read", can_read cannot be nil.')
+      end
+
+      if @can_write.nil?
+        invalid_properties.push('invalid value for "can_write", can_write cannot be nil.')
+      end
+
+      if @principal_id.nil?
+        invalid_properties.push('invalid value for "principal_id", principal_id cannot be nil.')
+      end
+
+      if @principal_table.nil?
+        invalid_properties.push('invalid value for "principal_table", principal_table 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 @can_delete.nil?
+      return false if @can_grant.nil?
+      return false if @can_read.nil?
+      return false if @can_write.nil?
+      return false if @principal_id.nil?
+      return false if @principal_table.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] can_delete Value to be assigned
+    def can_delete=(can_delete)
+      if can_delete.nil?
+        fail ArgumentError, 'can_delete cannot be nil'
+      end
+
+      @can_delete = can_delete
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] can_grant Value to be assigned
+    def can_grant=(can_grant)
+      if can_grant.nil?
+        fail ArgumentError, 'can_grant cannot be nil'
+      end
+
+      @can_grant = can_grant
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] can_read Value to be assigned
+    def can_read=(can_read)
+      if can_read.nil?
+        fail ArgumentError, 'can_read cannot be nil'
+      end
+
+      @can_read = can_read
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] can_write Value to be assigned
+    def can_write=(can_write)
+      if can_write.nil?
+        fail ArgumentError, 'can_write cannot be nil'
+      end
+
+      @can_write = can_write
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] principal_id Value to be assigned
+    def principal_id=(principal_id)
+      if principal_id.nil?
+        fail ArgumentError, 'principal_id cannot be nil'
+      end
+
+      @principal_id = principal_id
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] principal_table Value to be assigned
+    def principal_table=(principal_table)
+      if principal_table.nil?
+        fail ArgumentError, 'principal_table cannot be nil'
+      end
+
+      @principal_table = principal_table
+    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 &&
+          can_delete == o.can_delete &&
+          can_grant == o.can_grant &&
+          can_read == o.can_read &&
+          can_write == o.can_write &&
+          principal_id == o.principal_id &&
+          principal_table == o.principal_table
+    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
+      [can_delete, can_grant, can_read, can_write, principal_id, principal_table].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/resource_hit.rb

@@ -0,0 +1,216 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.5.1
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # One resource that matched, however it matched.  [`ResourceView`] is the same projection `list`/`show`/`create`/`update`/`annotate` and both search arms answer in — six near-identical projections collapsed into one. A hit adds scoring and nothing else.
+  class ResourceHit < ApiModelBase
+    # Where in the resource the match was — the closest chunk's block.  **Filled only by the wide arm**, and its absence is declared in advance rather than discovered here: [`super::act::ActDeclaration::discloses`] says which acts can report it. The wide arm matches at CHUNK grain and already computes which chunk was closest, then discards it collapsing to a per-resource score; recovering it is an argmin beside an aggregate that already runs.  `find-exact` structurally cannot: its index is one tsvector per RESOURCE, built by concatenating every chunk into a single blob, so the block boundary is gone before the query is asked. `follow-from` has no match position at all — it returns nodes reached by walking.  It sits on this type rather than on [`Scoring`] because `Scoring` is shared with [`RegionHit`], and a region is not somewhere inside a resource.  **`None` serializes as an explicit `\"located_at\": null`** (F4, ruled): the contract's prose is load-bearing on the null — every `located_at` is null today and the null unambiguously means *not declared* — and omitting the key made the resource-hit null indistinguishable from a shape with no such field, which is exactly the distinction [`RegionHit`] exists to draw.
+    attr_accessor :located_at
+
+    attr_accessor :resource
+
+    attr_accessor :scoring
+
+    # How a walk reached this resource — one entry per edge it was reached by.  **Filled only by `follow-from`**, and declared in advance rather than discovered: the act's [`super::act::ActDeclaration::discloses`] carries [`super::act::Disclosure::InputContribution`], which the enum predicted would *\"return when a walk carries origin\"*.  # EVERY parent, and the score corresponds to only one of them  `graph_score` is a `MAX` over paths; this is a union over **all** of them. They disagree by construction — a node reached both by a strong one-hop edge and a weak three-hop chain names both and scores from one. **The non-correspondence is declared here rather than repaired**, exactly as [`RegionHit::region`] carries `salience` beside `region_score` and says outright that the two are not rivals. Naming every parent is the more useful and the clearer answer; naming only the winning path's would make this field a second, silent statement about rank.  # ABSENT rather than null, which is the opposite of [`Self::located_at`]  The two look like the same question and are not, and F4's rule is what separates them. `located_at` is PRESENT-null because its null carries a *claim* — *no location declared* — that a missing key could not make. A collection has no such claim to carry: `[]` and absent would both mean \"no provenance\", so a null adds a third spelling of one fact. The key is therefore dropped for every act that is not a walk, and its presence means the same thing as the act's `discloses` already promised.  # No cap, and the reason is structural rather than \"the corpus is small\"  `[measured on prod — 2026-08-14]` at the deliberate worst case (25 highest-degree seeds, depth 3) the whole walk holds 9,434 entries with 124 on one node, while **the page that ships carries 125 in total and at most 9 on any row**. Nodes with enormous parent sets are reached by many long weak paths, so the score ranks them out and the limit sheds them before they are ever described. Capping would silently truncate provenance, which is the one thing this field exists to be trusted about.
+    attr_accessor :via
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'located_at' => :'located_at',
+        :'resource' => :'resource',
+        :'scoring' => :'scoring',
+        :'via' => :'via'
+      }
+    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
+      {
+        :'located_at' => :'MatchLocation',
+        :'resource' => :'ResourceView',
+        :'scoring' => :'Scoring',
+        :'via' => :'Array<ViaEntry>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'located_at',
+      ])
+    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::ResourceHit` 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::ResourceHit`. 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?(:'located_at')
+        self.located_at = attributes[:'located_at']
+      else
+        self.located_at = nil
+      end
+
+      if attributes.key?(:'resource')
+        self.resource = attributes[:'resource']
+      else
+        self.resource = nil
+      end
+
+      if attributes.key?(:'scoring')
+        self.scoring = attributes[:'scoring']
+      else
+        self.scoring = nil
+      end
+
+      if attributes.key?(:'via')
+        if (value = attributes[:'via']).is_a?(Array)
+          self.via = value
+        end
+      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 @resource.nil?
+        invalid_properties.push('invalid value for "resource", resource cannot be nil.')
+      end
+
+      if @scoring.nil?
+        invalid_properties.push('invalid value for "scoring", scoring 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 @resource.nil?
+      return false if @scoring.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] resource Value to be assigned
+    def resource=(resource)
+      if resource.nil?
+        fail ArgumentError, 'resource cannot be nil'
+      end
+
+      @resource = resource
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] scoring Value to be assigned
+    def scoring=(scoring)
+      if scoring.nil?
+        fail ArgumentError, 'scoring cannot be nil'
+      end
+
+      @scoring = scoring
+    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 &&
+          located_at == o.located_at &&
+          resource == o.resource &&
+          scoring == o.scoring &&
+          via == o.via
+    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
+      [located_at, resource, scoring, via].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