temper-rb 0.5.1

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

@@ -0,0 +1,226 @@
+=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
+  # Aggregated facet histograms for a list page: one per filterable dimension that publishes counts (`doc_type`, `stage`, `status`).  **Each histogram EXCLUDES its own filter predicate and is scoped by the others.** A histogram computed after its own predicate has been applied can only ever have one key — the key the caller already selected — which tells a browse UI nothing it did not already know and leaves every alternative unreachable, because the count that would justify offering it was filtered away. So `facets.doc_type` answers \"what would each doc-type yield under the *rest* of this filter set\", not \"what is in this page\". `total` is the fully-filtered count and is the number that describes the page; these three describe its neighbourhood.  Consequence for callers: filtering by doc-type and then reading `facets.doc_type` returns the whole distribution, including kinds no row on the page has. That is the point, not a leak — the counts are computed over the caller's already-visible set.
+  class ResourceFacets < ApiModelBase
+    # Doc-type histogram over the visible set filtered by `stage` and `status` but **not** by `doc_type_name` — so every reachable kind keeps a count and a browse UI can offer it.
+    attr_accessor :doc_type
+
+    # Stage histogram over the visible set filtered by `doc_type_name` and `status` but **not** by `stage`. Rows carrying no `temper-stage` are absent rather than counted under a synthetic key: \"has no stage\" is not a stage a caller can select.
+    attr_accessor :stage
+
+    # Status histogram over the visible set filtered by `doc_type_name` and `stage` but **not** by `status`. Rows carrying no `temper-status` are absent, for the same reason as `stage`.
+    attr_accessor :status
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'doc_type' => :'doc_type',
+        :'stage' => :'stage',
+        :'status' => :'status'
+      }
+    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
+      {
+        :'doc_type' => :'Hash<String, Integer>',
+        :'stage' => :'Hash<String, Integer>',
+        :'status' => :'Hash<String, Integer>'
+      }
+    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::ResourceFacets` 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::ResourceFacets`. 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?(:'doc_type')
+        if (value = attributes[:'doc_type']).is_a?(Hash)
+          self.doc_type = value
+        end
+      else
+        self.doc_type = nil
+      end
+
+      if attributes.key?(:'stage')
+        if (value = attributes[:'stage']).is_a?(Hash)
+          self.stage = value
+        end
+      else
+        self.stage = nil
+      end
+
+      if attributes.key?(:'status')
+        if (value = attributes[:'status']).is_a?(Hash)
+          self.status = value
+        end
+      else
+        self.status = 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 @doc_type.nil?
+        invalid_properties.push('invalid value for "doc_type", doc_type cannot be nil.')
+      end
+
+      if @stage.nil?
+        invalid_properties.push('invalid value for "stage", stage cannot be nil.')
+      end
+
+      if @status.nil?
+        invalid_properties.push('invalid value for "status", status 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 @doc_type.nil?
+      return false if @stage.nil?
+      return false if @status.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] doc_type Value to be assigned
+    def doc_type=(doc_type)
+      if doc_type.nil?
+        fail ArgumentError, 'doc_type cannot be nil'
+      end
+
+      @doc_type = doc_type
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] stage Value to be assigned
+    def stage=(stage)
+      if stage.nil?
+        fail ArgumentError, 'stage cannot be nil'
+      end
+
+      @stage = stage
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] status Value to be assigned
+    def status=(status)
+      if status.nil?
+        fail ArgumentError, 'status cannot be nil'
+      end
+
+      @status = status
+    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 &&
+          doc_type == o.doc_type &&
+          stage == o.stage &&
+          status == o.status
+    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
+      [doc_type, stage, status].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_facets_response.rb

@@ -0,0 +1,193 @@
+=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
+  # The live facets of one resource, oldest-first within each key.  **No server-side collapse.** One element per live `kb_properties` row. `get_meta` already offers the collapsed view (`open_meta.facet`, newest-wins, weight discarded); duplicating that here would reproduce the very concealment this read exists to end.  An empty `facets` list means *readable, and nothing asserted* — distinct from the `404` a caller who may not read the resource receives. See `facet_service::list_resource_facets` for why that distinction is safe rather than an existence oracle.
+  class ResourceFacetsResponse < ApiModelBase
+    attr_accessor :facets
+
+    attr_accessor :resource
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'facets' => :'facets',
+        :'resource' => :'resource'
+      }
+    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
+      {
+        :'facets' => :'Array<ResourceFacetRow>',
+        :'resource' => :'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::ResourceFacetsResponse` 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::ResourceFacetsResponse`. 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?(:'facets')
+        if (value = attributes[:'facets']).is_a?(Array)
+          self.facets = value
+        end
+      else
+        self.facets = nil
+      end
+
+      if attributes.key?(:'resource')
+        self.resource = attributes[:'resource']
+      else
+        self.resource = 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 @facets.nil?
+        invalid_properties.push('invalid value for "facets", facets cannot be nil.')
+      end
+
+      if @resource.nil?
+        invalid_properties.push('invalid value for "resource", resource 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 @facets.nil?
+      return false if @resource.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] facets Value to be assigned
+    def facets=(facets)
+      if facets.nil?
+        fail ArgumentError, 'facets cannot be nil'
+      end
+
+      @facets = facets
+    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
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          facets == o.facets &&
+          resource == o.resource
+    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
+      [facets, resource].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_filter.rb

@@ -0,0 +1,265 @@
+=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
+  # Narrowing over resources. Every field is AND-composed; an unset field narrows nothing.  **No field here has a closed vocabulary, and none is checked against one.** `[corrected — 2026-08-10, ADJ-10]` This claimed `doc_type`, `stage` and `status` were closed vocabularies whose unknown values raise `RefusalReason::UnknownFilterValue`. None of the three is: `stage` and `status` are free-form `Option<String>` and are refused wholesale by this door as `FilterNotApplicable`, and `doc_type` is a `kb_properties` row a resource may carry any value for. `[2026-08-15]` `UnknownFilterValue` used to be raised here for exactly one thing — an unrecognized `PropertySubject` — and **that reason is now gone with the type**, so nothing on this struct raises it.  The rule that replaces the old claim: *an unknown value in a genuinely closed set* is a refusal, because it can never match; *a string that may be perfectly legitimate and matches nothing in the scope you asked about* is an honest empty. `doc_type` is the second kind.
+  class ResourceFilter < ApiModelBase
+    # `kb_properties` where `property_key = 'doc_type'`.
+    attr_accessor :doc_type
+
+    # `kb_properties` where `property_key = 'facet'`.
+    attr_accessor :facets
+
+    attr_accessor :owner
+
+    # `kb_properties` rows owned by the resource itself: open key space, closed operator set. AND across the list, OR within a [`PropertyOp::Contains`].  **The three named fields above reach three keys; this one reaches the rest.** Sixty-seven of the seventy live property keys were narrowable by nothing on any act `[measured on prod — 2026-08-14]`.  **The container is the point, and it is the same container `EdgeFilter` has.** This is where a resource property predicate lives; it moved off `ActInvocation::properties`, where the same field meant different things depending on which act carried it. Given a container the subject tag has no job, which is why the tag no longer exists.  **`Contains` reads the value WHOLE — `kb_resource_properties`, never `kb_property_elements`** `[decided — 2026-08-15, Pete; 20260815000040]`. So it means exactly what [`EdgeFilter::properties`]'s `Contains` means. The element relation would silently narrow the operator: an array-shaped probe matches the whole value and matches *nothing* against an exploded element, and a `[]`-valued key is a row in the one and no rows in the other. The element view continues to serve `tags` and `facets`, whose semantics genuinely are AND-containment over elements.
+    attr_accessor :properties
+
+    attr_accessor :stage
+
+    attr_accessor :status
+
+    # `kb_properties` where `property_key = 'tags'`. AND-containment.
+    attr_accessor :tags
+
+    attr_accessor :title_contains
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'doc_type' => :'doc_type',
+        :'facets' => :'facets',
+        :'owner' => :'owner',
+        :'properties' => :'properties',
+        :'stage' => :'stage',
+        :'status' => :'status',
+        :'tags' => :'tags',
+        :'title_contains' => :'title_contains'
+      }
+    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
+      {
+        :'doc_type' => :'Array<String>',
+        :'facets' => :'Array<FacetPredicate>',
+        :'owner' => :'String',
+        :'properties' => :'Array<PropertyPredicate>',
+        :'stage' => :'String',
+        :'status' => :'String',
+        :'tags' => :'Array<String>',
+        :'title_contains' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'owner',
+        :'stage',
+        :'status',
+        :'title_contains'
+      ])
+    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::ResourceFilter` 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::ResourceFilter`. 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?(:'doc_type')
+        if (value = attributes[:'doc_type']).is_a?(Array)
+          self.doc_type = value
+        end
+      end
+
+      if attributes.key?(:'facets')
+        if (value = attributes[:'facets']).is_a?(Array)
+          self.facets = value
+        end
+      end
+
+      if attributes.key?(:'owner')
+        self.owner = attributes[:'owner']
+      end
+
+      if attributes.key?(:'properties')
+        if (value = attributes[:'properties']).is_a?(Array)
+          self.properties = value
+        end
+      end
+
+      if attributes.key?(:'stage')
+        self.stage = attributes[:'stage']
+      end
+
+      if attributes.key?(:'status')
+        self.status = attributes[:'status']
+      end
+
+      if attributes.key?(:'tags')
+        if (value = attributes[:'tags']).is_a?(Array)
+          self.tags = value
+        end
+      end
+
+      if attributes.key?(:'title_contains')
+        self.title_contains = attributes[:'title_contains']
+      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 !@doc_type.nil? && @doc_type.length > 256
+        invalid_properties.push('invalid value for "doc_type", number of items must be less than or equal to 256.')
+      end
+
+      if !@tags.nil? && @tags.length > 256
+        invalid_properties.push('invalid value for "tags", number of items must be less than or equal to 256.')
+      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 !@doc_type.nil? && @doc_type.length > 256
+      return false if !@tags.nil? && @tags.length > 256
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] doc_type Value to be assigned
+    def doc_type=(doc_type)
+      if doc_type.nil?
+        fail ArgumentError, 'doc_type cannot be nil'
+      end
+
+      if doc_type.length > 256
+        fail ArgumentError, 'invalid value for "doc_type", number of items must be less than or equal to 256.'
+      end
+
+      @doc_type = doc_type
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] tags Value to be assigned
+    def tags=(tags)
+      if tags.nil?
+        fail ArgumentError, 'tags cannot be nil'
+      end
+
+      if tags.length > 256
+        fail ArgumentError, 'invalid value for "tags", number of items must be less than or equal to 256.'
+      end
+
+      @tags = tags
+    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 &&
+          doc_type == o.doc_type &&
+          facets == o.facets &&
+          owner == o.owner &&
+          properties == o.properties &&
+          stage == o.stage &&
+          status == o.status &&
+          tags == o.tags &&
+          title_contains == o.title_contains
+    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
+      [doc_type, facets, owner, properties, stage, status, tags, title_contains].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