temper-rb 0.5.1

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

@@ -0,0 +1,451 @@
+=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 stage's mandatory disclosure. Exists whether or not the stage produced a result.  **`Eq` was dropped when `disclosed_regions` arrived** `[2026-08-20]`. `region_score` is an `f64` carried raw and un-normalized — see [`super::hits::RegionDisclosure`] for why — so this type is `PartialEq` and cannot be `Eq`. Nothing used it as a set or map key. [`super::envelope::StageResult`] never derived either.
+  class StageTrace < ApiModelBase
+    attr_accessor :act
+
+    # Which regions a `survey` stage matched, and at what score. Empty for every other act.  **This is what `discloses: [Disclosure::Region]` MEANS**, and until 2026-08-20 it meant nothing: the declaration existed in the registry with no consumer anywhere, no `region_id` in the assembler, and no field here — so a caller was told which regions matched by nothing at all. A declaration describes the DEPLOYED system; this field is what makes that true for `survey`.  **The pair rule**: [`super::envelope::StageResult::disclosed_regions`] carries the same value, for the same reason as [`Self::extent`], [`Self::terms_applied`] and the input numbers — the trace covers every stage and the results only the returned ones, so disagreeing copies would leave a reader unable to tell which was right. One definition (`disclosed_regions_for`), read twice.
+    attr_accessor :disclosed_regions
+
+    attr_accessor :disposition
+
+    # Complete / partial / indeterminate — **for every stage, not only the returned ones.** NOT a total; see [`Extent`].  **The pair rule**: [`super::envelope::StageResult::extent`] carries the same value, and the two must stay identical for the same reason as [`Self::input_ids`], [`Self::input_unusable`] and [`Self::refusal`] — the trace covers every stage and the results only the returned ones, so disagreeing copies would leave a reader unable to tell which was right.  **It is a fact about THIS stage's own bound.** A combinator applies none, so it reports `Complete`, meaning *\"I dropped nothing\"* rather than *\"the corpus behind my arms is exhausted\"*: an arm's `Partial` is not propagated up, because that would make one stage's extent a claim about another stage's bound. Every arm is a stage and carries its own entry here, which is how a reader sees that an `intersect` was computed against a truncated walk.
+    attr_accessor :extent
+
+    # How many ids this stage was handed **in total, across every input**. Zero for a stage with no input.  A sum rather than a per-input figure, because [`Self::input_unusable`] beside it is one conflated number by design and a total is the only thing the two can be compared against. The per-input split is in [`Self::inputs`].
+    attr_accessor :input_ids
+
+    # How many of them this stage could not use at all — invisible, nonexistent, or malformed.  Conflates the three on purpose — see [`super::envelope::StageResult::input_unusable`]. Naming the invisible case alone would make the trace a single-probe existence oracle.
+    attr_accessor :input_unusable
+
+    # What this stage was handed, one entry per input.  A reader can then tell without knowing the act vocabulary — *\"did stage 3 narrow or expand?\"* is the question `composition-is-legible` most obviously owes an answer to, and a caller reading only the response has no other way to get it. Empty for a stage with no input.  # This replaced a `relation` / `input_source` PAIR, and the pair could not be kept  `[widened — 2026-08-14]` with `ActInvocation::inputs`. Both were `Option`s describing *the* input, which was a total description while a stage had one. A bounded walk has two — a seed and a bound — and filling a single `relation` from whichever arrived first would answer *\"did this stage narrow or expand?\"* with **half the truth and no marker saying so**. That is worse than not answering: the field's whole job is to be the thing a caller trusts instead of knowing the act vocabulary.  Keeping the two fields beside this list was the alternative and is the drift-by-construction this contract keeps removing — two spellings of one fact, free to disagree the moment a second input appears.
+    attr_accessor :inputs
+
+    attr_accessor :narrowed_by
+
+    # How many ids this stage PRODUCED — the mirror of [`Self::input_ids`], and what lets a reader ask *\"did this stage earn its place?\"* rather than only *\"did it find anything?\"*  Carried for EVERY stage, which is the point: an intermediate ships no rows, and a combinator can never be a returned stage at all, so for those this is the only account of their size there is.  **It counts what the corpus yielded, not what came back.** For a returned stage it may exceed that stage's hydrated rows, because an id that stopped being visible between the two statements is dropped from the rows and still counted here. The two are different questions and only the gap between them is interesting.
+    attr_accessor :produced_ids
+
+    # Present iff `disposition` is `refused` — the reason and standing-aware detail. The trace covers every stage while results cover only returned ones, so this is the ONLY refusal record for an intermediate stage. **The pair rule**: identical to [`super::envelope::StageResult::refusal`], for the same reason as the input numbers.
+    attr_accessor :refusal
+
+    # A stage's name, and — because [`StageName::parse`] is the only constructor — a proof that the name is a safe SQL identifier.  The compiler (beat C, Task 9) emits stage names as CTE identifiers. Parse-don't-validate is the whole design: a name that cannot be constructed cannot reach SQL, so there is deliberately no `new_unchecked`. The accepted shape is `[a-z][a-z0-9_]{0,62}` — a leading lowercase letter, then up to 62 more lowercase-alphanumeric-or-underscore characters (63 total).
+    attr_accessor :stage
+
+    # The APPLIED value of every admitted term: the page this stage actually RAN with, clamped to the act's published ceiling and defaulted where the caller named nothing.  **The pair rule** again — identical to [`super::envelope::StageResult::terms_applied`], from one [`super::registry::applied_terms`] DEFINITION rather than two. That function's own doc argues it from the other end: *\"The one definition, and it exists because there are two consumers who must not disagree… Computed twice, they would eventually differ, and the difference would be a response claiming a page size that did not run.\"* It already had two consumers (the compiler binds these values, the assembler reports them); this adds a second READER of the map the assembler already holds, never a second definition of it.  **\"One definition\" is the claim; \"one evaluation\" is not.** `stage_numbers` is called once per carrier, so a returned stage evaluates it twice. What forbids disagreement is that the definition is pure — the property to preserve if it is ever edited.  Empty for a combinator, which admits no terms — a union runs no page of its own.  **No \"you were clamped\" flag rides beside this, and this field does not add one.** That call is not taken here — it belongs to [`super::registry::applied_terms`], which states it: ceilings are published per act, so the applied value is the whole story, and clamping to a ceiling nobody published would be the bug rather than the silence. `temper-services`' `the_page_a_stage_reports_is_the_clamped_one_the_statement_actually_ran` pins the other half — *\"reporting the request back would make `terms_applied` an echo rather than a disclosure\"* — so what rides here is what ran, never what was asked for.
+    attr_accessor :terms_applied
+
+    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
+      {
+        :'act' => :'act',
+        :'disclosed_regions' => :'disclosed_regions',
+        :'disposition' => :'disposition',
+        :'extent' => :'extent',
+        :'input_ids' => :'input_ids',
+        :'input_unusable' => :'input_unusable',
+        :'inputs' => :'inputs',
+        :'narrowed_by' => :'narrowed_by',
+        :'produced_ids' => :'produced_ids',
+        :'refusal' => :'refusal',
+        :'stage' => :'stage',
+        :'terms_applied' => :'terms_applied'
+      }
+    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
+      {
+        :'act' => :'ActName',
+        :'disclosed_regions' => :'Array<RegionDisclosure>',
+        :'disposition' => :'StageDisposition',
+        :'extent' => :'Extent',
+        :'input_ids' => :'Integer',
+        :'input_unusable' => :'Integer',
+        :'inputs' => :'Array<StageInputTrace>',
+        :'narrowed_by' => :'Array<NarrowedBy>',
+        :'produced_ids' => :'Integer',
+        :'refusal' => :'ActRefusal',
+        :'stage' => :'String',
+        :'terms_applied' => :'Hash<String, Integer>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'refusal',
+      ])
+    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::StageTrace` 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::StageTrace`. 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?(:'act')
+        self.act = attributes[:'act']
+      else
+        self.act = nil
+      end
+
+      if attributes.key?(:'disclosed_regions')
+        if (value = attributes[:'disclosed_regions']).is_a?(Array)
+          self.disclosed_regions = value
+        end
+      end
+
+      if attributes.key?(:'disposition')
+        self.disposition = attributes[:'disposition']
+      else
+        self.disposition = nil
+      end
+
+      if attributes.key?(:'extent')
+        self.extent = attributes[:'extent']
+      else
+        self.extent = nil
+      end
+
+      if attributes.key?(:'input_ids')
+        self.input_ids = attributes[:'input_ids']
+      else
+        self.input_ids = nil
+      end
+
+      if attributes.key?(:'input_unusable')
+        self.input_unusable = attributes[:'input_unusable']
+      else
+        self.input_unusable = nil
+      end
+
+      if attributes.key?(:'inputs')
+        if (value = attributes[:'inputs']).is_a?(Array)
+          self.inputs = value
+        end
+      end
+
+      if attributes.key?(:'narrowed_by')
+        if (value = attributes[:'narrowed_by']).is_a?(Array)
+          self.narrowed_by = value
+        end
+      else
+        self.narrowed_by = nil
+      end
+
+      if attributes.key?(:'produced_ids')
+        self.produced_ids = attributes[:'produced_ids']
+      else
+        self.produced_ids = nil
+      end
+
+      if attributes.key?(:'refusal')
+        self.refusal = attributes[:'refusal']
+      end
+
+      if attributes.key?(:'stage')
+        self.stage = attributes[:'stage']
+      else
+        self.stage = nil
+      end
+
+      if attributes.key?(:'terms_applied')
+        if (value = attributes[:'terms_applied']).is_a?(Hash)
+          self.terms_applied = value
+        end
+      else
+        self.terms_applied = 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 @act.nil?
+        invalid_properties.push('invalid value for "act", act cannot be nil.')
+      end
+
+      if @disposition.nil?
+        invalid_properties.push('invalid value for "disposition", disposition cannot be nil.')
+      end
+
+      if @extent.nil?
+        invalid_properties.push('invalid value for "extent", extent cannot be nil.')
+      end
+
+      if @input_ids.nil?
+        invalid_properties.push('invalid value for "input_ids", input_ids cannot be nil.')
+      end
+
+      if @input_unusable.nil?
+        invalid_properties.push('invalid value for "input_unusable", input_unusable cannot be nil.')
+      end
+
+      if @narrowed_by.nil?
+        invalid_properties.push('invalid value for "narrowed_by", narrowed_by cannot be nil.')
+      end
+
+      if @produced_ids.nil?
+        invalid_properties.push('invalid value for "produced_ids", produced_ids cannot be nil.')
+      end
+
+      if @stage.nil?
+        invalid_properties.push('invalid value for "stage", stage cannot be nil.')
+      end
+
+      pattern = Regexp.new(/^[a-z][a-z0-9_]{0,62}$/)
+      if @stage !~ pattern
+        invalid_properties.push("invalid value for \"stage\", must conform to the pattern #{pattern}.")
+      end
+
+      if @terms_applied.nil?
+        invalid_properties.push('invalid value for "terms_applied", terms_applied 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 @act.nil?
+      return false if @disposition.nil?
+      return false if @extent.nil?
+      return false if @input_ids.nil?
+      return false if @input_unusable.nil?
+      return false if @narrowed_by.nil?
+      return false if @produced_ids.nil?
+      return false if @stage.nil?
+      return false if @stage !~ Regexp.new(/^[a-z][a-z0-9_]{0,62}$/)
+      return false if @terms_applied.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] act Value to be assigned
+    def act=(act)
+      if act.nil?
+        fail ArgumentError, 'act cannot be nil'
+      end
+
+      @act = act
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] disposition Value to be assigned
+    def disposition=(disposition)
+      if disposition.nil?
+        fail ArgumentError, 'disposition cannot be nil'
+      end
+
+      @disposition = disposition
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] extent Value to be assigned
+    def extent=(extent)
+      if extent.nil?
+        fail ArgumentError, 'extent cannot be nil'
+      end
+
+      @extent = extent
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] input_ids Value to be assigned
+    def input_ids=(input_ids)
+      if input_ids.nil?
+        fail ArgumentError, 'input_ids cannot be nil'
+      end
+
+      @input_ids = input_ids
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] input_unusable Value to be assigned
+    def input_unusable=(input_unusable)
+      if input_unusable.nil?
+        fail ArgumentError, 'input_unusable cannot be nil'
+      end
+
+      @input_unusable = input_unusable
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] narrowed_by Value to be assigned
+    def narrowed_by=(narrowed_by)
+      if narrowed_by.nil?
+        fail ArgumentError, 'narrowed_by cannot be nil'
+      end
+
+      @narrowed_by = narrowed_by
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] produced_ids Value to be assigned
+    def produced_ids=(produced_ids)
+      if produced_ids.nil?
+        fail ArgumentError, 'produced_ids cannot be nil'
+      end
+
+      @produced_ids = produced_ids
+    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
+
+      pattern = Regexp.new(/^[a-z][a-z0-9_]{0,62}$/)
+      if stage !~ pattern
+        fail ArgumentError, "invalid value for \"stage\", must conform to the pattern #{pattern}."
+      end
+
+      @stage = stage
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] terms_applied Value to be assigned
+    def terms_applied=(terms_applied)
+      if terms_applied.nil?
+        fail ArgumentError, 'terms_applied cannot be nil'
+      end
+
+      @terms_applied = terms_applied
+    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 &&
+          act == o.act &&
+          disclosed_regions == o.disclosed_regions &&
+          disposition == o.disposition &&
+          extent == o.extent &&
+          input_ids == o.input_ids &&
+          input_unusable == o.input_unusable &&
+          inputs == o.inputs &&
+          narrowed_by == o.narrowed_by &&
+          produced_ids == o.produced_ids &&
+          refusal == o.refusal &&
+          stage == o.stage &&
+          terms_applied == o.terms_applied
+    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
+      [act, disclosed_regions, disposition, extent, input_ids, input_unusable, inputs, narrowed_by, produced_ids, refusal, stage, terms_applied].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/standing.rb

@@ -0,0 +1,43 @@
+=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
+  class Standing
+    DENIED = "denied".freeze
+    REQUESTED = "requested".freeze
+    APPROVED = "approved".freeze
+    REVOKED = "revoked".freeze
+    DEACTIVATED = "deactivated".freeze
+
+    def self.all_vars
+      @all_vars ||= [DENIED, REQUESTED, APPROVED, REVOKED, DEACTIVATED].freeze
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def self.build_from_hash(value)
+      new.build_from_hash(value)
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def build_from_hash(value)
+      return value if Standing.all_vars.include?(value)
+      raise "Invalid ENUM value #{value} for class #Standing"
+    end
+  end
+end