smplkit 3.0.119 → 3.0.121

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9911186cf0810c9d76cc16feb24f9a155d8c6708fce3edc406b581b5c9376f1c
-  data.tar.gz: '009441ca636ade20f9f9a4cbec10d9ea9d2255b81549a2bc7e1274a94091e05d'
+  metadata.gz: 6f9ea84a0877be007a56f9f05502329795bb0d8f291cd0df226f2a1b96548980
+  data.tar.gz: d93a0cd1b4ae0b03032903a8a64743e8b31fca815a78ecdbc8bca5689be18e64
 SHA512:
-  metadata.gz: 5558c39aa882f3bc403613ac51bf20b8f8dddbd4eb663126847a6b5f3a0c5fd961ec13f939c274e3c39c46f3cc2af8d2e44540b999c1e6e4b2239e1a1886e4ec
-  data.tar.gz: e944872fdef51e90924897ee1173e0dcad70f36255e95a1372f99690f238478852890e54ba1c1a62bbebab2fd7b73f81cecbb4a27591cb79382a348edb46657c
+  metadata.gz: 43272f094727b6ecc958a8850582e775a9f0013b0572ff96718c53c26626662692f2f8c4896e1d643b70370bb926214f19cb5c8d714c67c4f9dcabb10cf2d265
+  data.tar.gz: 496db856f49fd0950584092683867bfb66f5d0c66eb28c8d3da7d8e8b7ae13f2524483f0a82af348403252123aa6714364b579d77495c9b3aab02721eaa1bdcb

data/lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/retry_policy.rb

@@ -31,8 +31,17 @@ module SmplkitGeneratedClient::Jobs
     # The ceiling on the wait between retries, in seconds, for `exponential` backoff — once the doubling reaches it, every subsequent retry waits this long. Only valid with `exponential` backoff; omit it for `fixed`.
     attr_accessor :max_delay_seconds
 
-    # Which failures are retried. A run is retried only when its failure matches this set; an empty set retries nothing. Some failures are never retried regardless of this value.
-    attr_accessor :retry_on
+    # Retry a run that failed because the request did not complete within the job's timeout. Defaults to `false` (timeouts are not retried).
+    attr_accessor :retry_on_timeout
+
+    # Retry a run that failed because the destination could not be reached (DNS, connection refused, TLS, or transport error). Defaults to `false` (connection errors are not retried).
+    attr_accessor :retry_on_connection_error
+
+    # Allowlist of response status patterns to retry when a run fails because the response did not match the job's success status. Each element is either an exact 3-digit HTTP code (e.g. `429`) or a status class (`1xx`, `2xx`, `3xx`, `4xx`, `5xx`) — for example `[\"429\", \"5xx\"]` to retry on rate-limit and any server error. Empty (the default) matches no status, so nothing is retried on a non-success response.
+    attr_accessor :retry_statuses
+
+    # Subtractions from `retry_statuses`, using the same exact-code or class syntax. A status that matches both lists is not retried — `except` wins on overlap — so `retry_statuses` of `[\"5xx\"]` with `retry_statuses_except` of `[\"501\"]` retries every server error except `501`. An element that does not overlap `retry_statuses` is allowed and simply has no effect. Empty (the default) subtracts nothing.
+    attr_accessor :retry_statuses_except
 
     # When the policy was created.
     attr_accessor :created_at
@@ -76,7 +85,10 @@ module SmplkitGeneratedClient::Jobs
         :'backoff' => :'backoff',
         :'delay_seconds' => :'delay_seconds',
         :'max_delay_seconds' => :'max_delay_seconds',
-        :'retry_on' => :'retry_on',
+        :'retry_on_timeout' => :'retry_on_timeout',
+        :'retry_on_connection_error' => :'retry_on_connection_error',
+        :'retry_statuses' => :'retry_statuses',
+        :'retry_statuses_except' => :'retry_statuses_except',
         :'created_at' => :'created_at',
         :'updated_at' => :'updated_at',
         :'deleted_at' => :'deleted_at',
@@ -102,7 +114,10 @@ module SmplkitGeneratedClient::Jobs
         :'backoff' => :'String',
         :'delay_seconds' => :'Integer',
         :'max_delay_seconds' => :'Integer',
-        :'retry_on' => :'RetryOn',
+        :'retry_on_timeout' => :'Boolean',
+        :'retry_on_connection_error' => :'Boolean',
+        :'retry_statuses' => :'Array<String>',
+        :'retry_statuses_except' => :'Array<String>',
         :'created_at' => :'Time',
         :'updated_at' => :'Time',
         :'deleted_at' => :'Time',
@@ -165,8 +180,28 @@ module SmplkitGeneratedClient::Jobs
         self.max_delay_seconds = attributes[:'max_delay_seconds']
       end
 
-      if attributes.key?(:'retry_on')
-        self.retry_on = attributes[:'retry_on']
+      if attributes.key?(:'retry_on_timeout')
+        self.retry_on_timeout = attributes[:'retry_on_timeout']
+      else
+        self.retry_on_timeout = false
+      end
+
+      if attributes.key?(:'retry_on_connection_error')
+        self.retry_on_connection_error = attributes[:'retry_on_connection_error']
+      else
+        self.retry_on_connection_error = false
+      end
+
+      if attributes.key?(:'retry_statuses')
+        if (value = attributes[:'retry_statuses']).is_a?(Array)
+          self.retry_statuses = value
+        end
+      end
+
+      if attributes.key?(:'retry_statuses_except')
+        if (value = attributes[:'retry_statuses_except']).is_a?(Array)
+          self.retry_statuses_except = value
+        end
       end
 
       if attributes.key?(:'created_at')
@@ -333,7 +368,10 @@ module SmplkitGeneratedClient::Jobs
           backoff == o.backoff &&
           delay_seconds == o.delay_seconds &&
           max_delay_seconds == o.max_delay_seconds &&
-          retry_on == o.retry_on &&
+          retry_on_timeout == o.retry_on_timeout &&
+          retry_on_connection_error == o.retry_on_connection_error &&
+          retry_statuses == o.retry_statuses &&
+          retry_statuses_except == o.retry_statuses_except &&
           created_at == o.created_at &&
           updated_at == o.updated_at &&
           deleted_at == o.deleted_at &&
@@ -349,7 +387,7 @@ module SmplkitGeneratedClient::Jobs
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [name, max_retries, backoff, delay_seconds, max_delay_seconds, retry_on, created_at, updated_at, deleted_at, version].hash
+      [name, max_retries, backoff, delay_seconds, max_delay_seconds, retry_on_timeout, retry_on_connection_error, retry_statuses, retry_statuses_except, created_at, updated_at, deleted_at, version].hash
     end
 
     # Builds the object from hash

data/lib/smplkit/_generated/jobs/lib/smplkit_jobs_client.rb

@@ -32,7 +32,6 @@ require 'smplkit_jobs_client/models/job_resource'
 require 'smplkit_jobs_client/models/job_response'
 require 'smplkit_jobs_client/models/list_meta'
 require 'smplkit_jobs_client/models/pagination_meta'
-require 'smplkit_jobs_client/models/retry_on'
 require 'smplkit_jobs_client/models/retry_policy'
 require 'smplkit_jobs_client/models/retry_policy_create_request'
 require 'smplkit_jobs_client/models/retry_policy_create_resource'

data/lib/smplkit/_generated/jobs/spec/models/retry_policy_spec.rb

@@ -61,7 +61,25 @@ describe SmplkitGeneratedClient::Jobs::RetryPolicy do
     end
   end
 
-  describe 'test attribute "retry_on"' do
+  describe 'test attribute "retry_on_timeout"' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  describe 'test attribute "retry_on_connection_error"' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  describe 'test attribute "retry_statuses"' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  describe 'test attribute "retry_statuses_except"' do
     it 'should work' do
       # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
     end

data/lib/smplkit/jobs/client.rb

@@ -12,8 +12,10 @@ require "time"
 #
 #   client.jobs.{new_recurring_job,new_manual_job,schedule,get,list,delete,run,usage}
 #   client.jobs.runs.{list,get,cancel,rerun}
+#   client.jobs.retry_policies.{new,list,get,delete}
 #   Job#{save,delete,trigger,list_runs}
 #   Run#{rerun,cancel}
+#   RetryPolicy#{save,delete}
 #
 # A job is enabled per environment: a recurring (cron) job may be enabled in
 # several environments at once, a manual job (no schedule) runs only when
@@ -47,16 +49,29 @@ module Smplkit
       #   any of these environment keys. +nil+ falls back to the client's
       #   configured environment (if any), otherwise covers every environment you
       #   can access.
+      # @param triggers [Array<String>, nil] Restrict to runs started by any of
+      #   these triggers (see {RunTrigger}) — e.g. +[RunTrigger::RETRY]+ for
+      #   automatic retries. Serialized as a comma-joined +filter[trigger]+
+      #   (any-of). +nil+ or empty covers every trigger.
+      # @param last_run_only [Boolean] When +true+, collapse the result to the
+      #   last completed (succeeded / failed / canceled) run per
+      #   job-and-environment; in-flight runs are excluded. The other filters
+      #   apply first, then the collapse. Defaults to +false+; the query param is
+      #   sent only when +true+.
       # @param page_size [Integer, nil] Maximum number of runs to return in this
       #   page. +nil+ uses the server default.
       # @param after [String, nil] Opaque cursor from a previous page; returns
       #   the runs that follow it. +nil+ starts from the first page.
       # @return [Array<Smplkit::Jobs::Run>] The runs in this page.
-      def list(job: nil, environments: nil, page_size: nil, after: nil)
+      def list(job: nil, environments: nil, triggers: nil, last_run_only: false, page_size: nil, after: nil)
         opts = {}
         opts[:filter_job] = job unless job.nil?
         filter_environment = Jobs.resolve_environment_filter(environments, @environment)
         opts[:filter_environment] = filter_environment unless filter_environment.nil?
+        opts[:filter_trigger] = triggers.join(",") unless triggers.nil? || triggers.empty?
+        # The generated default would emit +last_run_only=false+ on every call;
+        # send the param only when explicitly requested.
+        opts[:last_run_only] = true if last_run_only
         opts[:page_size] = page_size unless page_size.nil?
         opts[:page_after] = after unless after.nil?
 
@@ -94,6 +109,161 @@ module Smplkit
       end
     end
 
+    # +client.jobs.retry_policies.*+ — manage reusable, account-global retry
+    # policies.
+    #
+    # A {RetryPolicy} is an active record: build one with {#new}, set fields, and
+    # call +#save+; then reference it from a job's +retry_policy+ (see
+    # {JobsClient#new_recurring_job} and {Job#set_retry_policy}). Retry policies
+    # are account-global — never environment-scoped.
+    class RetryPoliciesClient
+      # @param api [SmplkitGeneratedClient::Jobs::RetryPoliciesApi] The generated
+      #   retry-policies API.
+      def initialize(api)
+        @api = api
+      end
+
+      # Construct an unsaved {RetryPolicy} bound to this client. Call +#save+ on
+      # the returned instance to create it.
+      #
+      # @param id [String] Caller-supplied unique identifier for the policy.
+      #   Unique within the account and immutable; the service returns 409 if
+      #   another live policy already uses this id.
+      # @param name [String] Human-readable name for the policy.
+      # @param max_retries [Integer] How many times a failed run is retried after
+      #   the initial attempt — +3+ means up to 4 attempts total. +0+ disables
+      #   retries. Maximum 10.
+      # @param backoff [String] How the wait between retries grows; one of
+      #   {Backoff}.
+      # @param delay_seconds [Integer] The wait before a retry, in seconds — the
+      #   constant wait for {Backoff::FIXED}, or the base that doubles each retry
+      #   for {Backoff::EXPONENTIAL}.
+      # @param max_delay_seconds [Integer, nil] Ceiling on the wait between
+      #   retries, for {Backoff::EXPONENTIAL} backoff only. +nil+ (the default)
+      #   leaves it uncapped; omit it for {Backoff::FIXED}.
+      # @param retry_on_timeout [Boolean] Retry a run that timed out. Defaults to
+      #   +false+.
+      # @param retry_on_connection_error [Boolean] Retry a run whose destination
+      #   could not be reached. Defaults to +false+.
+      # @param retry_statuses [Array<String>, nil] Allowlist of response-status
+      #   patterns to retry on a non-success response. Each element is an exact
+      #   3-digit code (e.g. +"429"+) or a class token (+"1xx"+ … +"5xx"+).
+      #   +nil+ (the default) retries no statuses.
+      # @param retry_statuses_except [Array<String>, nil] Patterns subtracted from
+      #   +retry_statuses+, using the same syntax; +except+ wins on overlap.
+      #   +nil+ (the default) subtracts nothing.
+      # @return [Smplkit::Jobs::RetryPolicy]
+      def new(id, name:, max_retries:, backoff:, delay_seconds:, max_delay_seconds: nil,
+              retry_on_timeout: false, retry_on_connection_error: false,
+              retry_statuses: nil, retry_statuses_except: nil)
+        RetryPolicy.new(
+          self,
+          id: id, name: name, max_retries: max_retries, backoff: backoff,
+          delay_seconds: delay_seconds, max_delay_seconds: max_delay_seconds,
+          retry_on_timeout: retry_on_timeout,
+          retry_on_connection_error: retry_on_connection_error,
+          retry_statuses: retry_statuses, retry_statuses_except: retry_statuses_except
+        )
+      end
+
+      # List retry policies in the account.
+      #
+      # @param name [String, nil] Return only policies whose name contains this
+      #   text (case-insensitive). +nil+ lists all.
+      # @param page_number [Integer, nil] 1-based page to return. +nil+ returns
+      #   the first page.
+      # @param page_size [Integer, nil] Maximum number of policies to return in
+      #   this page. +nil+ uses the server default.
+      # @return [Array<Smplkit::Jobs::RetryPolicy>] The policies in this page.
+      def list(name: nil, page_number: nil, page_size: nil)
+        opts = {}
+        opts[:filter_name] = name unless name.nil?
+        opts[:page_number] = page_number unless page_number.nil?
+        opts[:page_size] = page_size unless page_size.nil?
+
+        resp = Jobs.call_api { @api.list_retry_policies(opts) }
+        (resp.data || []).map { |r| RetryPolicy.from_resource(r, client: self) }
+      end
+
+      # Fetch a single retry policy by its id.
+      #
+      # @param id [String] Identifier of the policy to fetch.
+      # @return [Smplkit::Jobs::RetryPolicy] The matching policy.
+      # @raise [Smplkit::NotFoundError] when no policy with this id exists.
+      def get(id)
+        resp = Jobs.call_api { @api.get_retry_policy(id) }
+        RetryPolicy.from_resource(resp.data, client: self)
+      end
+
+      # Delete a retry policy by its id.
+      #
+      # @param id [String] Identifier of the policy to delete.
+      # @return [nil]
+      def delete(id)
+        Jobs.call_api { @api.delete_retry_policy(id) }
+        nil
+      end
+
+      # @api private — POST a new retry policy. Called by {RetryPolicy#save} on
+      #   unsaved instances. The jobs service requires a caller-supplied
+      #   +data.id+ on create and 409s on conflict.
+      def _create_retry_policy(policy)
+        if policy.id.nil? || policy.id.empty?
+          raise ArgumentError, "RetryPolicy.id is required on create (caller-supplied key)"
+        end
+
+        resp = Jobs.call_api { @api.create_retry_policy(build_create_body(policy)) }
+        RetryPolicy.from_resource(resp.data, client: self)
+      end
+
+      # @api private — Full-replace PUT for an existing retry policy. Called by
+      #   {RetryPolicy#save} on instances with +created_at+.
+      def _update_retry_policy(policy)
+        raise ArgumentError, "cannot update a RetryPolicy with no id" if policy.id.nil?
+
+        resp = Jobs.call_api { @api.update_retry_policy(policy.id, build_body(policy)) }
+        RetryPolicy.from_resource(resp.data, client: self)
+      end
+
+      private
+
+      # Build the generated attributes model shared by create and update. The
+      # four retry-condition fields are always sent; +max_delay_seconds+ is sent
+      # only when present (omitting it leaves the policy uncapped / is invalid for
+      # fixed backoff).
+      def build_retry_policy_attrs(policy)
+        attrs = {
+          name: policy.name,
+          max_retries: policy.max_retries,
+          backoff: policy.backoff,
+          delay_seconds: policy.delay_seconds,
+          retry_on_timeout: policy.retry_on_timeout,
+          retry_on_connection_error: policy.retry_on_connection_error,
+          retry_statuses: Array(policy.retry_statuses).map(&:to_s),
+          retry_statuses_except: Array(policy.retry_statuses_except).map(&:to_s)
+        }
+        attrs[:max_delay_seconds] = policy.max_delay_seconds unless policy.max_delay_seconds.nil?
+        SmplkitGeneratedClient::Jobs::RetryPolicy.new(attrs)
+      end
+
+      def build_create_body(policy)
+        # Create uses the distinct RetryPolicyCreateRequest envelope; the jobs
+        # service requires data.id (the caller-supplied key) on create.
+        resource = SmplkitGeneratedClient::Jobs::RetryPolicyCreateResource.new(
+          id: policy.id.to_s, type: "retry_policy", attributes: build_retry_policy_attrs(policy)
+        )
+        SmplkitGeneratedClient::Jobs::RetryPolicyCreateRequest.new(data: resource)
+      end
+
+      def build_body(policy)
+        # Update path uses the generic RetryPolicyRequest envelope.
+        resource = SmplkitGeneratedClient::Jobs::RetryPolicyResource.new(
+          id: policy.id.to_s, type: "retry_policy", attributes: build_retry_policy_attrs(policy)
+        )
+        SmplkitGeneratedClient::Jobs::RetryPolicyRequest.new(data: resource)
+      end
+    end
+
     # The Smpl Jobs client — accessed via +client.jobs+.
     #
     # Unlike Config/Flags/Logging, Jobs has no live "phone-home" agent — no
@@ -103,8 +273,10 @@ module Smplkit
     #
     #   client.jobs.{new_recurring_job,new_manual_job,schedule,get,list,delete,run,usage}
     #   client.jobs.runs.{list,get,cancel,rerun}
+    #   client.jobs.retry_policies.{new,list,get,delete}
     #   Job#{save,delete,trigger,list_runs}
     #   Run#{rerun,cancel}
+    #   RetryPolicy#{save,delete}
     #
     # Build a standalone Smpl Jobs transport from resolved config.
     #
@@ -139,6 +311,10 @@ module Smplkit
       # @return [RunsClient] Run history and run actions (+client.jobs.runs+).
       attr_reader :runs
 
+      # @return [RetryPoliciesClient] Reusable retry policies
+      #   (+client.jobs.retry_policies+).
+      attr_reader :retry_policies
+
       # @param api_key [String, nil] API key. When omitted, resolved from
       #   +SMPLKIT_API_KEY+ or +~/.smplkit+.
       # @param profile [String, nil] Named +~/.smplkit+ profile section.
@@ -164,6 +340,7 @@ module Smplkit
         @environment = environment
         @api = SmplkitGeneratedClient::Jobs::JobsApi.new(auth)
         @runs = RunsClient.new(SmplkitGeneratedClient::Jobs::RunsApi.new(auth), environment: environment)
+        @retry_policies = RetryPoliciesClient.new(SmplkitGeneratedClient::Jobs::RetryPoliciesApi.new(auth))
         @usage_api = SmplkitGeneratedClient::Jobs::UsageApi.new(auth)
       end
 
@@ -191,8 +368,14 @@ module Smplkit
       #   live job already uses this id.
       # @param name [String] Human-readable name for the job.
       # @param schedule [String] The base cadence — a 5-field cron expression
-      #   evaluated in UTC (e.g. +"0 2 * * *"+) — that every environment inherits
-      #   unless it sets its own override.
+      #   evaluated in the job's +timezone+ (UTC by default), e.g. +"0 2 * * *"+ —
+      #   that every environment inherits unless it sets its own override.
+      # @param timezone [String, nil] Base IANA timezone the cron +schedule+ is
+      #   evaluated in (e.g. +"America/New_York"+), DST-aware. +nil+ (the default)
+      #   means UTC. Every environment inherits it unless it overrides it.
+      # @param retry_policy [String, nil] Base retry policy for failed runs — the
+      #   id of a {Smplkit::Jobs::RetryPolicy}, overridable per environment. +nil+
+      #   (the default) uses the built-in +"Default"+ policy, which never retries.
       # @param configuration [Smplkit::Jobs::HttpConfig] The HTTP request the job
       #   sends each time it fires.
       # @param description [String, nil] Optional free-text description.
@@ -205,11 +388,11 @@ module Smplkit
       # @param concurrency_policy [String] How overlapping runs are handled.
       #   Defaults to +"ALLOW"+.
       # @return [Smplkit::Jobs::Job]
-      def new_recurring_job(id, name:, schedule:, configuration:, description: nil,
-                            environments: nil, concurrency_policy: "ALLOW")
+      def new_recurring_job(id, name:, schedule:, configuration:, timezone: nil, retry_policy: nil,
+                            description: nil, environments: nil, concurrency_policy: "ALLOW")
         _new_job(
-          id, name: name, schedule: schedule, configuration: configuration,
-              description: description, environments: environments,
+          id, name: name, schedule: schedule, timezone: timezone, retry_policy: retry_policy,
+              configuration: configuration, description: description, environments: environments,
               concurrency_policy: concurrency_policy, environment: nil
         )
       end
@@ -234,12 +417,15 @@ module Smplkit
       #   override). The job is triggerable only in environments enabled here.
       # @param concurrency_policy [String] How overlapping runs are handled.
       #   Defaults to +"ALLOW"+.
+      # @param retry_policy [String, nil] Retry policy for failed runs — the id of
+      #   a {Smplkit::Jobs::RetryPolicy}, overridable per environment. +nil+ (the
+      #   default) uses the built-in +"Default"+ policy, which never retries.
       # @return [Smplkit::Jobs::Job]
       def new_manual_job(id, name:, configuration:, description: nil,
-                         environments: nil, concurrency_policy: "ALLOW")
+                         environments: nil, concurrency_policy: "ALLOW", retry_policy: nil)
         _new_job(
-          id, name: name, schedule: nil, configuration: configuration,
-              description: description, environments: environments,
+          id, name: name, schedule: nil, retry_policy: retry_policy,
+              configuration: configuration, description: description, environments: environments,
               concurrency_policy: concurrency_policy, environment: nil
         )
       end
@@ -259,14 +445,17 @@ module Smplkit
       # @param description [String, nil] Optional free-text description.
       # @param concurrency_policy [String] How overlapping runs are handled.
       #   Defaults to +"ALLOW"+.
+      # @param retry_policy [String, nil] Retry policy for failed runs — the id of
+      #   a {Smplkit::Jobs::RetryPolicy}. +nil+ (the default) uses the built-in
+      #   +"Default"+ policy, which never retries.
       # @param environment [String, nil] The environment the job is born in.
       #   Defaults to the client's configured environment.
       # @return [Smplkit::Jobs::Job]
       def schedule(id, name:, schedule:, configuration:, description: nil,
-                   concurrency_policy: "ALLOW", environment: nil)
+                   concurrency_policy: "ALLOW", retry_policy: nil, environment: nil)
         _new_job(
-          id, name: name, schedule: schedule.iso8601, configuration: configuration,
-              description: description, environments: nil,
+          id, name: name, schedule: schedule.iso8601, retry_policy: retry_policy,
+              configuration: configuration, description: description, environments: nil,
               concurrency_policy: concurrency_policy, environment: environment
         )
       end
@@ -377,12 +566,15 @@ module Smplkit
       # public constructors ({#new_recurring_job}, {#new_manual_job}, {#schedule})
       # funnel through here.
       def _new_job(id, name:, schedule:, configuration:, description:,
-                   environments:, concurrency_policy:, environment:)
+                   environments:, concurrency_policy:, environment:,
+                   timezone: nil, retry_policy: nil)
         Job.new(
           self,
           id: id,
           name: name,
           schedule: schedule,
+          timezone: timezone,
+          retry_policy: retry_policy,
           configuration: configuration,
           description: description,
           environments: Jobs.normalize_environments(environments),
@@ -394,15 +586,17 @@ module Smplkit
       # Convert the wrapper +environments+ map to the generated model hash.
       #
       # Each entry's +enabled+ is always written; a per-environment +schedule+
-      # (cron) override, +timezone+ override, and +configuration+ override are
-      # each sent only when present (omit to inherit the job's base +schedule+ /
-      # +timezone+ / +configuration+). The read-only per-environment
-      # +next_run_at+ is never written.
+      # (cron) override, +timezone+ override, +retry_policy+ override, and
+      # +configuration+ override are each sent only when present (omit to inherit
+      # the job's base +schedule+ / +timezone+ / +retry_policy+ /
+      # +configuration+). The read-only per-environment +next_run_at+ is never
+      # written.
       def environments_to_wire(environments)
         (environments || {}).each_with_object({}) do |(env_key, env), out|
           attrs = { enabled: env.enabled }
           attrs[:schedule] = env.schedule unless env.schedule.nil?
           attrs[:timezone] = env.timezone unless env.timezone.nil?
+          attrs[:retry_policy] = env.retry_policy unless env.retry_policy.nil?
           attrs[:configuration] = HttpConfig.to_wire(env.configuration) unless env.configuration.nil?
           out[env_key.to_s] = SmplkitGeneratedClient::Jobs::JobEnvironment.new(attrs)
         end
@@ -425,6 +619,9 @@ module Smplkit
         # explicit +null+ creates a manual job, omitting +timezone+ simply
         # inherits UTC — so it is sent only when present.)
         attrs[:timezone] = job.timezone unless job.timezone.nil?
+        # +retry_policy+ id; an unset +nil+ is omitted, leaving the server
+        # default (the built-in +Default+ policy, which never retries).
+        attrs[:retry_policy] = job.retry_policy unless job.retry_policy.nil?
         environments = job.environments
         attrs[:environments] = environments_to_wire(environments) unless environments.nil? || environments.empty?
         SmplkitGeneratedClient::Jobs::Job.new(attrs)

data/lib/smplkit/jobs/models.rb

@@ -79,8 +79,8 @@ module Smplkit
     # (+{ enabled: true, schedule: "0 3 * * *", configuration: HttpConfig.new(...) }+)
     # so callers can use the lightweight hash form without importing the model. A
     # dict-form +configuration+ override is coerced to an {HttpConfig} so it
-    # serializes on save; optional +schedule+ cron and +timezone+ overrides pass
-    # through.
+    # serializes on save; optional +schedule+ cron, +timezone+, and
+    # +retry_policy+ overrides pass through.
     #
     # @api private
     def self.normalize_environments(environments)
@@ -96,6 +96,7 @@ module Smplkit
                                 enabled: value[:enabled] || value["enabled"] || false,
                                 schedule: value[:schedule] || value["schedule"],
                                 timezone: value[:timezone] || value["timezone"],
+                                retry_policy: value[:retry_policy] || value["retry_policy"],
                                 configuration: cfg
                               )
                             end
@@ -120,13 +121,27 @@ module Smplkit
     #
     # - +MANUAL+: A +run+ / +trigger+ call started it on demand.
     # - +RERUN+: It repeats an earlier run.
+    # - +RETRY+: An automatic retry of a failed run, per the job's retry policy.
     # - +SCHEDULE+: The job's schedule fired.
     module RunTrigger
       MANUAL = "MANUAL"
       RERUN = "RERUN"
+      RETRY = "RETRY"
       SCHEDULE = "SCHEDULE"
 
-      VALUES = [MANUAL, RERUN, SCHEDULE].freeze
+      VALUES = [MANUAL, RERUN, RETRY, SCHEDULE].freeze
+    end
+
+    # How the wait between retries grows (a retry policy's backoff strategy).
+    #
+    # - +EXPONENTIAL+: Double the wait each retry — +delay_seconds+, then +2×+,
+    #   +4×+, … — capped at +max_delay_seconds+.
+    # - +FIXED+: Wait a constant +delay_seconds+ before every retry.
+    module Backoff
+      EXPONENTIAL = "exponential"
+      FIXED = "fixed"
+
+      VALUES = [EXPONENTIAL, FIXED].freeze
     end
 
     # HTTP verb a job uses when it fires.
@@ -300,6 +315,10 @@ module Smplkit
     #     present, it must be a valid IANA zone key (e.g. +"America/New_York"+);
     #     it may be set on an environment that inherits the base schedule (it
     #     need not also override {#schedule}). Sent on writes only when present.
+    # @!attribute [rw] retry_policy
+    #   @return [String, nil] Optional per-environment retry-policy override — the
+    #     id of a {RetryPolicy} (or +"Default"+). +nil+ (the default) inherits the
+    #     job's base {Job#retry_policy}. Sent on writes only when present.
     # @!attribute [rw] configuration
     #   @return [HttpConfig, nil] Optional per-environment request configuration
     #     that fully replaces the job's base {Job#configuration} for this
@@ -310,8 +329,11 @@ module Smplkit
     #   @return [String, nil] Read-only. The next scheduled fire time in this
     #     environment. +nil+ when the environment is not enabled, or once a
     #     one-off run has fired. Never written back on save.
-    JobEnvironment = Struct.new(:enabled, :schedule, :timezone, :configuration, :next_run_at, keyword_init: true) do
-      def initialize(enabled: false, schedule: nil, timezone: nil, configuration: nil, next_run_at: nil)
+    JobEnvironment = Struct.new(
+      :enabled, :schedule, :timezone, :retry_policy, :configuration, :next_run_at, keyword_init: true
+    ) do
+      def initialize(enabled: false, schedule: nil, timezone: nil, retry_policy: nil,
+                     configuration: nil, next_run_at: nil)
         super
       end
 
@@ -328,6 +350,7 @@ module Smplkit
           enabled: src.enabled.nil? ? false : src.enabled,
           schedule: src.schedule,
           timezone: src.timezone,
+          retry_policy: src.retry_policy,
           configuration: cfg.nil? ? nil : HttpConfig.from_wire(cfg),
           next_run_at: src.next_run_at
         )
@@ -406,6 +429,13 @@ module Smplkit
       #   present.
       attr_accessor :timezone
 
+      # @return [String, nil] The base retry policy for failed runs — the id of a
+      #   {RetryPolicy}, overridable per environment via
+      #   {JobEnvironment#retry_policy}. +nil+ (the default, omitted on the wire)
+      #   uses the built-in +"Default"+ policy, which never retries. Set it with
+      #   {#set_retry_policy}; sent on writes only when present.
+      attr_accessor :retry_policy
+
       # @return [HttpConfig] The base HTTP request to perform when the job fires.
       #   Per-environment overrides live in {#environments}.
       attr_accessor :configuration
@@ -436,7 +466,7 @@ module Smplkit
       attr_accessor :birth_environment
 
       def initialize(client = nil, id:, name:, configuration:, schedule: nil,
-                     timezone: nil, description: nil, environments: nil,
+                     timezone: nil, retry_policy: nil, description: nil, environments: nil,
                      kind: nil, type: "http", concurrency_policy: "ALLOW",
                      birth_environment: nil, created_at: nil,
                      updated_at: nil, deleted_at: nil, version: nil)
@@ -449,6 +479,7 @@ module Smplkit
         @type = type
         @schedule = schedule
         @timezone = timezone
+        @retry_policy = retry_policy
         @configuration = configuration
         @concurrency_policy = concurrency_policy
         @birth_environment = birth_environment
@@ -588,17 +619,27 @@ module Smplkit
       # the cadence within that environment; it cannot turn a one-off job
       # recurring or vice-versa. Call {#save} to persist.
       #
+      # Because the timezone is an integral part of a cron cadence, a +timezone+
+      # may be supplied alongside the schedule; when given it sets the same
+      # scope's timezone too (equivalent to a follow-up {#set_timezone}). Omit it
+      # to leave the timezone untouched. For a timezone-only change, use
+      # {#set_timezone}.
+      #
       # @param schedule [String] An ISO-8601 datetime, a 5-field UTC cron
       #   expression, or the literal +"now"+ (base); a 5-field UTC cron
       #   expression (per-environment).
+      # @param timezone [String, nil] An optional IANA timezone to set on the
+      #   same scope (recurring jobs only). +nil+ (the default) leaves the
+      #   timezone untouched.
       # @param environment [String, nil] An environment key for a per-environment
       #   override, or +nil+ to set the base schedule.
-      def set_schedule(schedule, environment: nil)
+      def set_schedule(schedule, timezone: nil, environment: nil)
         if environment.nil?
           @schedule = schedule
         else
           _environment_override(environment).schedule = schedule
         end
+        set_timezone(timezone, environment: environment) unless timezone.nil?
       end
 
       # Set the IANA timezone the cron schedule is evaluated in — base
@@ -624,6 +665,31 @@ module Smplkit
         end
       end
 
+      # Set the retry policy for failed runs — base (+environment+ omitted) or
+      # per-environment.
+      #
+      # With +environment+ omitted (the default), sets the base {#retry_policy}
+      # every environment inherits unless it overrides it. With an +environment+
+      # given, sets that environment's per-environment override on
+      # {#environments}, creating the override entry if it doesn't exist yet
+      # (preserving any already-set +enabled+ / +schedule+ / +timezone+ /
+      # +configuration+ on it). Call {#save} to persist.
+      #
+      # Accepts either a {RetryPolicy} instance (its id is used) or a policy id
+      # string — pass +"Default"+ for the built-in never-retry policy.
+      #
+      # @param retry_policy [RetryPolicy, String] A {RetryPolicy} or a policy id.
+      # @param environment [String, nil] An environment key for a per-environment
+      #   override, or +nil+ to set the base retry policy.
+      def set_retry_policy(retry_policy, environment: nil)
+        policy_id = retry_policy.is_a?(RetryPolicy) ? retry_policy.id : retry_policy
+        if environment.nil?
+          @retry_policy = policy_id
+        else
+          _environment_override(environment).retry_policy = policy_id
+        end
+      end
+
       # Trigger one immediate, manual run of this job (a +MANUAL+ run).
       #
       # @param environment [String, nil] Environment the run executes in.
@@ -641,17 +707,25 @@ module Smplkit
       #
       # @param environment [String, nil] Restrict to runs stamped with this
       #   environment. +nil+ covers every environment you can access.
+      # @param triggers [Array<String>, nil] Restrict to runs started by any of
+      #   these triggers (see {RunTrigger}) — e.g. +[RunTrigger::RETRY]+ for
+      #   automatic retries. +nil+ covers every trigger.
+      # @param last_run_only [Boolean] When +true+, return only the last
+      #   completed run per environment (in-flight runs excluded). Defaults to
+      #   +false+.
       # @param page_size [Integer, nil] Maximum number of runs to return in this
       #   page.
       # @param after [String, nil] Opaque cursor from a previous page.
       # @return [Array<Smplkit::Jobs::Run>] The runs in this page.
       # @raise [RuntimeError] when this job has no bound client.
-      def list_runs(environment: nil, page_size: nil, after: nil)
+      def list_runs(environment: nil, triggers: nil, last_run_only: false, page_size: nil, after: nil)
         raise "Job was constructed without a client; cannot list runs" if @client.nil?
 
         @client.runs.list(
           job: @id,
           environments: environment.nil? ? nil : [environment],
+          triggers: triggers,
+          last_run_only: last_run_only,
           page_size: page_size,
           after: after
         )
@@ -678,6 +752,7 @@ module Smplkit
         @type = other.type
         @schedule = other.schedule
         @timezone = other.timezone
+        @retry_policy = other.retry_policy
         @configuration = other.configuration
         @concurrency_policy = other.concurrency_policy
         @created_at = other.created_at
@@ -709,6 +784,7 @@ module Smplkit
           type: a.type || "http",
           schedule: a.schedule,
           timezone: a.timezone,
+          retry_policy: a.retry_policy,
           configuration: HttpConfig.from_wire(a.configuration),
           concurrency_policy: a.concurrency_policy || "ALLOW",
           created_at: a.created_at,
@@ -719,6 +795,16 @@ module Smplkit
       end
     end
 
+    # Where a +RETRY+ run sits in its retry chain (read-only).
+    #
+    # @!attribute [rw] of
+    #   @return [String] Id of the chain's original run — the first attempt that
+    #     failed and started the chain.
+    # @!attribute [rw] attempt
+    #   @return [Integer] Which retry this run is — +1+ for the first retry, +2+
+    #     for the second, and so on.
+    RunRetry = Struct.new(:of, :attempt, keyword_init: true)
+
     # A single execution of a job (read-only) with +rerun+ / +cancel+ actions.
     #
     # Runs are created and mutated by the jobs service, not by clients; clients
@@ -741,6 +827,9 @@ module Smplkit
     #     {RunTrigger} constants: +SCHEDULE+, +MANUAL+ (run now), or +RERUN+.
     # @!attribute [rw] rerun_of
     #   @return [String, nil] The source run's id; set only when +trigger+ is +RERUN+.
+    # @!attribute [rw] retry
+    #   @return [RunRetry, nil] Retry-chain position, populated only when
+    #     +trigger+ is +RETRY+; +nil+ otherwise.
     # @!attribute [rw] scheduled_for
     #   @return [String, nil] The intended fire time for a scheduled run; +nil+
     #     for manual / rerun runs.
@@ -767,7 +856,7 @@ module Smplkit
     # @!attribute [rw] created_at
     #   @return [String, nil] When the run was enqueued (became +PENDING+).
     Run = Struct.new(
-      :id, :job, :job_version, :environment, :trigger, :rerun_of, :scheduled_for,
+      :id, :job, :job_version, :environment, :trigger, :rerun_of, :retry, :scheduled_for,
       :status, :started_at, :finished_at, :pending_duration_ms, :run_duration_ms,
       :total_duration_ms, :failure_reason, :error, :request, :result, :created_at,
       keyword_init: true
@@ -780,6 +869,12 @@ module Smplkit
       # @return [Run] The hydrated run.
       def self.from_resource(resource, runs: nil)
         a = resource.attributes
+        # The retry-chain position is populated only on a +RETRY+ run; the
+        # generated model exposes it as +_retry+ (+retry+ is a Ruby keyword).
+        retry_chain = a._retry
+        retry_pos = if a.trigger == RunTrigger::RETRY && !retry_chain.nil?
+                      RunRetry.new(of: retry_chain.of, attempt: retry_chain.attempt)
+                    end
         new(
           id: resource.id,
           job: a.job,
@@ -787,6 +882,7 @@ module Smplkit
           environment: a.environment,
           trigger: a.trigger,
           rerun_of: a.rerun_of,
+          retry: retry_pos,
           scheduled_for: a.scheduled_for,
           status: a.status,
           started_at: a.started_at,
@@ -857,5 +953,170 @@ module Smplkit
         )
       end
     end
+
+    # A named, reusable automatic-retry policy.
+    #
+    # Active-record style: instantiate via +client.jobs.retry_policies.new(...)+,
+    # mutate fields directly, and call {#save} to persist or {#delete} to remove.
+    # Reference a saved policy from a job's {Job#retry_policy} (see
+    # {JobsClient#new_recurring_job} and {Job#set_retry_policy}). Retry policies
+    # are account-global — never environment-scoped.
+    #
+    # A policy decides whether and how a failed run is retried. A job that
+    # references nothing uses the built-in +"Default"+ policy, which never
+    # retries.
+    class RetryPolicy
+      # @return [String] Caller-supplied unique identifier for the policy (the
+      #   resource +id+). Unique within the account and immutable; the service
+      #   returns 409 if another live policy already uses this id.
+      attr_accessor :id
+
+      # @return [String] Human-readable name for the policy.
+      attr_accessor :name
+
+      # @return [Integer] How many times a failed run is retried after the
+      #   initial attempt — +3+ means up to 4 attempts total. +0+ disables
+      #   retries. Maximum 10.
+      attr_accessor :max_retries
+
+      # @return [String] How the wait between retries grows; one of {Backoff}.
+      attr_accessor :backoff
+
+      # @return [Integer] The wait before a retry, in seconds — the constant wait
+      #   for {Backoff::FIXED}, or the base that doubles each retry for
+      #   {Backoff::EXPONENTIAL}.
+      attr_accessor :delay_seconds
+
+      # @return [Integer, nil] Ceiling on the wait between retries, for
+      #   {Backoff::EXPONENTIAL} backoff only. +nil+ (the default, omitted on the
+      #   wire) leaves it uncapped; omit it for {Backoff::FIXED}.
+      attr_accessor :max_delay_seconds
+
+      # @return [Boolean] Retry a run that timed out. Defaults to +false+.
+      attr_accessor :retry_on_timeout
+
+      # @return [Boolean] Retry a run whose destination could not be reached (a
+      #   connection error). Defaults to +false+.
+      attr_accessor :retry_on_connection_error
+
+      # @return [Array<String>] Allowlist of response-status patterns to retry on
+      #   a non-success response. Each element is an exact 3-digit code (e.g.
+      #   +"429"+) or a class token (+"1xx"+ … +"5xx"+). Defaults to an empty
+      #   list (retries no statuses).
+      attr_accessor :retry_statuses
+
+      # @return [Array<String>] Patterns subtracted from {#retry_statuses}, using
+      #   the same exact-code or class syntax. A status matching both lists is not
+      #   retried — +except+ wins on overlap. Defaults to an empty list.
+      attr_accessor :retry_statuses_except
+
+      # @return [String, nil] ISO-8601 timestamp of first persist. +nil+ for an
+      #   unsaved instance.
+      attr_accessor :created_at
+
+      # @return [String, nil] ISO-8601 timestamp of the most recent mutation.
+      attr_accessor :updated_at
+
+      # @return [String, nil] Timestamp when the policy was deleted; +nil+ for
+      #   live policies.
+      attr_accessor :deleted_at
+
+      # @return [Integer, nil] Monotonic version counter, bumped on every
+      #   server-side write.
+      attr_accessor :version
+
+      def initialize(client = nil, id:, name:, max_retries:, backoff:, delay_seconds:,
+                     max_delay_seconds: nil, retry_on_timeout: false,
+                     retry_on_connection_error: false, retry_statuses: nil,
+                     retry_statuses_except: nil, created_at: nil,
+                     updated_at: nil, deleted_at: nil, version: nil)
+        @client = client
+        @id = id
+        @name = name
+        @max_retries = max_retries
+        @backoff = backoff
+        @delay_seconds = delay_seconds
+        @max_delay_seconds = max_delay_seconds
+        @retry_on_timeout = retry_on_timeout
+        @retry_on_connection_error = retry_on_connection_error
+        @retry_statuses = retry_statuses || []
+        @retry_statuses_except = retry_statuses_except || []
+        @created_at = created_at
+        @updated_at = updated_at
+        @deleted_at = deleted_at
+        @version = version
+      end
+
+      # Create this policy, or full-replace it if it already exists.
+      #
+      # Upsert behavior is driven by {#created_at}: a policy with no +created_at+
+      # is created (POST); otherwise it's full-replace updated (PUT). After the
+      # call, every field is refreshed from the server response.
+      #
+      # @return [self]
+      def save
+        raise "RetryPolicy was constructed without a client; cannot save" if @client.nil?
+
+        updated = @created_at.nil? ? @client._create_retry_policy(self) : @client._update_retry_policy(self)
+        _apply(updated)
+        self
+      end
+      alias save! save
+
+      # Delete this policy on the server.
+      #
+      # @return [nil]
+      def delete
+        raise "RetryPolicy was constructed without a client or id; cannot delete" if @client.nil? || @id.nil?
+
+        @client.delete(@id)
+      end
+      alias delete! delete
+
+      # @api private
+      def _apply(other)
+        @id = other.id
+        @name = other.name
+        @max_retries = other.max_retries
+        @backoff = other.backoff
+        @delay_seconds = other.delay_seconds
+        @max_delay_seconds = other.max_delay_seconds
+        @retry_on_timeout = other.retry_on_timeout
+        @retry_on_connection_error = other.retry_on_connection_error
+        @retry_statuses = other.retry_statuses
+        @retry_statuses_except = other.retry_statuses_except
+        @created_at = other.created_at
+        @updated_at = other.updated_at
+        @deleted_at = other.deleted_at
+        @version = other.version
+      end
+
+      # @api private — Build a {RetryPolicy} from a JSON:API resource returned by
+      #   the jobs service, binding it to +client+ so {#save} and {#delete} work.
+      #
+      # @param resource [Object] The JSON:API resource (id + attributes).
+      # @param client [RetryPoliciesClient, nil] Client to bind the policy to.
+      # @return [RetryPolicy] The hydrated policy.
+      def self.from_resource(resource, client: nil)
+        a = resource.attributes
+        new(
+          client,
+          id: resource.id,
+          name: a.name,
+          max_retries: a.max_retries,
+          backoff: a.backoff,
+          delay_seconds: a.delay_seconds,
+          max_delay_seconds: a.max_delay_seconds,
+          retry_on_timeout: a.retry_on_timeout || false,
+          retry_on_connection_error: a.retry_on_connection_error || false,
+          retry_statuses: a.retry_statuses || [],
+          retry_statuses_except: a.retry_statuses_except || [],
+          created_at: a.created_at,
+          updated_at: a.updated_at,
+          deleted_at: a.deleted_at,
+          version: a.version
+        )
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smplkit
 version: !ruby/object:Gem::Version
-  version: 3.0.119
+  version: 3.0.121
 platform: ruby
 authors:
 - Smpl Solutions LLC
@@ -778,7 +778,6 @@ files:
 - lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/job_response.rb
 - lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/list_meta.rb
 - lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/pagination_meta.rb
-- lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/retry_on.rb
 - lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/retry_policy.rb
 - lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/retry_policy_create_request.rb
 - lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/retry_policy_create_resource.rb
@@ -815,7 +814,6 @@ files:
 - lib/smplkit/_generated/jobs/spec/models/job_spec.rb
 - lib/smplkit/_generated/jobs/spec/models/list_meta_spec.rb
 - lib/smplkit/_generated/jobs/spec/models/pagination_meta_spec.rb
-- lib/smplkit/_generated/jobs/spec/models/retry_on_spec.rb
 - lib/smplkit/_generated/jobs/spec/models/retry_policy_create_request_spec.rb
 - lib/smplkit/_generated/jobs/spec/models/retry_policy_create_resource_spec.rb
 - lib/smplkit/_generated/jobs/spec/models/retry_policy_list_response_spec.rb

data/lib/smplkit/_generated/jobs/lib/smplkit_jobs_client/models/retry_on.rb

@@ -1,185 +0,0 @@
-=begin
-#smplkit Jobs API
-
-#Scheduled HTTP job execution API for smplkit.
-
-The version of the OpenAPI document: 0.1.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.22.0
-
-=end
-
-require 'date'
-require 'time'
-
-module SmplkitGeneratedClient::Jobs
-  # Which failures a policy retries. An empty policy (both lists empty or absent) retries nothing.
-  class RetryOn < ApiModelBase
-    # Response status codes that should be retried when a run fails because the response did not match the job's success status (for example `[429, 503]` to retry on rate-limit and unavailable). Each is a 3-digit HTTP status code. Empty matches no status.
-    attr_accessor :statuses
-
-    # Failure reasons that should be retried: `TIMEOUT` (the run did not complete in time), `CONNECTION_ERROR` (the endpoint could not be reached), or `NON_SUCCESS_STATUS` (any non-success response, regardless of `statuses`). Empty matches no reason.
-    attr_accessor :reasons
-
-    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
-      {
-        :'statuses' => :'statuses',
-        :'reasons' => :'reasons'
-      }
-    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
-      {
-        :'statuses' => :'Array<Integer>',
-        :'reasons' => :'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 `SmplkitGeneratedClient::Jobs::RetryOn` 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 `SmplkitGeneratedClient::Jobs::RetryOn`. 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?(:'statuses')
-        if (value = attributes[:'statuses']).is_a?(Array)
-          self.statuses = value
-        end
-      end
-
-      if attributes.key?(:'reasons')
-        if (value = attributes[:'reasons']).is_a?(Array)
-          self.reasons = 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
-      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'
-      true
-    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 &&
-          statuses == o.statuses &&
-          reasons == o.reasons
-    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
-      [statuses, reasons].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/smplkit/_generated/jobs/spec/models/retry_on_spec.rb

@@ -1,46 +0,0 @@
-=begin
-#smplkit Jobs API
-
-#Scheduled HTTP job execution API for smplkit.
-
-The version of the OpenAPI document: 0.1.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.22.0
-
-=end
-
-require 'spec_helper'
-require 'json'
-require 'date'
-
-# Unit tests for SmplkitGeneratedClient::Jobs::RetryOn
-# Automatically generated by openapi-generator (https://openapi-generator.tech)
-# Please update as you see appropriate
-describe SmplkitGeneratedClient::Jobs::RetryOn do
-  #let(:instance) { SmplkitGeneratedClient::Jobs::RetryOn.new }
-
-  describe 'test an instance of RetryOn' do
-    it 'should create an instance of RetryOn' do
-      # uncomment below to test the instance creation
-      #expect(instance).to be_instance_of(SmplkitGeneratedClient::Jobs::RetryOn)
-    end
-  end
-
-  describe 'test attribute "statuses"' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-    end
-  end
-
-  describe 'test attribute "reasons"' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-      # validator = Petstore::EnumTest::EnumAttributeValidator.new('Array<String>', ["TIMEOUT", "CONNECTION_ERROR", "NON_SUCCESS_STATUS"])
-      # validator.allowable_values.each do |value|
-      #   expect { instance.reasons = value }.not_to raise_error
-      # end
-    end
-  end
-
-end