crisphive 0.1.0 → 0.3.0

data/lib/crisphive/api/job_request_business_api.rb

@@ -1,7 +1,7 @@
 =begin
-#CrispHive Developer API
+#Crisphive Developer API
 
-#Public REST API for integrating CrispHive from your own backend. Authenticate every request with a secret API key as a Bearer token (`Authorization: Bearer chsk_live_…`). The key prefix selects the data environment: `chsk_live_…` → production (live), `chsk_test_…` → sandbox (isolated test).  **Key scopes (restricted keys).** A key is either *full-access* (can call every endpoint below) or *restricted* to a set of permission codes chosen at creation — the same codes as the dashboard permission grid (e.g. `customers_view`, `job_create`, `team_manage`). A restricted key calling an endpoint outside its scope gets `403`. The full code list is the permission catalog (`GET /permission/modules` on the dashboard API). Create, scope, and revoke keys from the business dashboard.  Every response is wrapped in the envelope `{ \"error_code\": 0, \"message\": \"Success\", \"data\": <payload> }`.
+#Public REST API for integrating Crisphive from your own backend. Authenticate every request with a secret API key as a Bearer token (`Authorization: Bearer chsk_live_…`). The key prefix selects the data environment: `chsk_live_…` → production (live), `chsk_test_…` → sandbox (isolated test).  **Key scopes (restricted keys).** A key is either *full-access* (can call every endpoint below) or *restricted* to a set of permission codes chosen at creation — the same codes as the dashboard permission grid (e.g. `customers_view`, `job_create`, `team_manage`). A restricted key calling an endpoint outside its scope gets `403`. The full code list is the permission catalog (`GET /permission/modules` on the dashboard API). Create, scope, and revoke keys from the business dashboard.  Every response is wrapped in the envelope `{ \"error_code\": 0, \"message\": \"Success\", \"data\": <payload> }`.
 
 The version of the OpenAPI document: 1.0
 
@@ -19,31 +19,33 @@ module Crisphive
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
-    # Create a job request (business actor)
-    # @param job_request_create_request [JobRequestCreateRequest] Booking payload
+    # Book, schedule and confirm a job in one call
+    # Creates the job, quotes it (job_duration_minutes, or the job type's default_duration_minutes) and confirms it at scheduled_at on the customer's behalf — the dashboard's \"book for a caller\" in a single request, built for voice agents and automation platforms that cannot run create → quote → slots → confirm.  Customer: send `customer_id`, or `customer` (+ `address`) to match-or-create by phone/email — a caller who already exists is matched, never duplicated. Find a caller first with listCustomers?phone=.  Every input is validated BEFORE anything is written (time and business timezone, future start, a duration or a job-type default, non-negative mobilization/demobilization minutes, active job type, phone format); those failures are ordinary 4xx and create nothing.  ⚠️ A `technician_id` the engine cannot honour at that time is refused BEFORE anything is written: `409 JOB_REQUEST_TECH_INFEASIBLE`, no job, no customer, no webhook. Change the technician or the time and send again with a NEW Idempotency-Key: like every 4xx here the 409 is cached against its key for 24h, so the same key replays it (same body) or answers 422 IDEMPOTENCY_KEY_REUSE (changed body). This check is BEST-EFFORT — if the scheduling engine cannot be reached it is skipped and the call proceeds, so a pinned request can still come back as the 200 + `refusal` below. Handle both.  ⚠️ ONE carve-out: a `p0` whose pinned technician is merely BUSY is NOT refused here. The job is created and the call answers 200 + `refusal` carrying JOB_REQUEST_P0_REQUIRES_DISPLACEMENT, because the remedy for that code is the emergency flow and listEmergencyCandidates / previewEmergencyReschedule / commitEmergencyReschedule all require `emergency_job_id` — a 409 carries no job id. Read `job_id` off the 200 and run the emergency flow; do not re-book. Every other doomed pin on a `p0` (out of area, missing skills, not a lead) still answers 409.  ⚠️ A SECOND carve-out, narrower: for a `p0`, a PERSONAL-CALENDAR overlap on the pinned technician is not refused here either — naming them is treated as having already phoned them — and the call answers 200 + `confirmed: true`. Nothing on this response discloses it; the only record is the business's activity feed (`job_calendar_override`). `calendar_busy`/`calendar_conflict` therefore never appear in the 409 reason vocabulary below when the pin is a `p0` naming a technician explicitly (this endpoint never books a crew, so the exclusion is unconditional here).  ⚠️ Otherwise, once the job is created it is never discarded, and the call answers 200 even if scheduling then fails: `confirmed: false` with `refusal` (stage + the exact error_code/data the quote or confirm endpoint would have returned, e.g. JOB_REQUEST_NO_TECHNICIAN_AVAILABLE with blockers). The job is then quoted and waiting in the coordinator's queue — tell the caller the office will confirm a time. Retry with the SAME Idempotency-Key to replay the result; a new key books a second job.  P0 dispatch: send `emergency` with `priority: \"p0\"`. `dispatch: \"now\"` plans the displacement cascade BEFORE anything is written — a refusal is a 409 creating nothing — then books, quotes and commits it. `dispatch: \"later\"` parks a quoted P0 in the tray and ignores the other fields.  ⚠️ `emergency.expected_move_ids` is REQUIRED with `dispatch: \"now\"` and has three meanings: omitted is refused, `[]` means \"my preview showed no displacement\" and commits a free lane, and a named set is the fence. Get the ids from previewEmergencyReschedule.  ⚠️ A refusal AFTER the job is created answers 200 with `confirmed: false` and `refusal.stage: \"dispatch\"`. Read `job_id`, re-preview with previewEmergencyReschedule and commit with commitEmergencyReschedule. Never re-book.
+    # @param job_request_book_and_confirm_request [JobRequestBookAndConfirmRequest] Book and confirm in one call
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_timezone Customer IANA timezone
-    # @return [CreateJobRequest200Response]
-    def create_job_request(job_request_create_request, opts = {})
-      data, _status_code, _headers = create_job_request_with_http_info(job_request_create_request, opts)
+    # @option opts [String] :idempotency_key Makes retries safe: a repeat send with the same key returns the original result instead of booking again
+    # @return [BookAndConfirmJobRequest200Response]
+    def book_and_confirm_job_request(job_request_book_and_confirm_request, opts = {})
+      data, _status_code, _headers = book_and_confirm_job_request_with_http_info(job_request_book_and_confirm_request, opts)
       data
     end
 
-    # Create a job request (business actor)
-    # @param job_request_create_request [JobRequestCreateRequest] Booking payload
+    # Book, schedule and confirm a job in one call
+    # Creates the job, quotes it (job_duration_minutes, or the job type&#39;s default_duration_minutes) and confirms it at scheduled_at on the customer&#39;s behalf — the dashboard&#39;s \&quot;book for a caller\&quot; in a single request, built for voice agents and automation platforms that cannot run create → quote → slots → confirm.  Customer: send &#x60;customer_id&#x60;, or &#x60;customer&#x60; (+ &#x60;address&#x60;) to match-or-create by phone/email — a caller who already exists is matched, never duplicated. Find a caller first with listCustomers?phone&#x3D;.  Every input is validated BEFORE anything is written (time and business timezone, future start, a duration or a job-type default, non-negative mobilization/demobilization minutes, active job type, phone format); those failures are ordinary 4xx and create nothing.  ⚠️ A &#x60;technician_id&#x60; the engine cannot honour at that time is refused BEFORE anything is written: &#x60;409 JOB_REQUEST_TECH_INFEASIBLE&#x60;, no job, no customer, no webhook. Change the technician or the time and send again with a NEW Idempotency-Key: like every 4xx here the 409 is cached against its key for 24h, so the same key replays it (same body) or answers 422 IDEMPOTENCY_KEY_REUSE (changed body). This check is BEST-EFFORT — if the scheduling engine cannot be reached it is skipped and the call proceeds, so a pinned request can still come back as the 200 + &#x60;refusal&#x60; below. Handle both.  ⚠️ ONE carve-out: a &#x60;p0&#x60; whose pinned technician is merely BUSY is NOT refused here. The job is created and the call answers 200 + &#x60;refusal&#x60; carrying JOB_REQUEST_P0_REQUIRES_DISPLACEMENT, because the remedy for that code is the emergency flow and listEmergencyCandidates / previewEmergencyReschedule / commitEmergencyReschedule all require &#x60;emergency_job_id&#x60; — a 409 carries no job id. Read &#x60;job_id&#x60; off the 200 and run the emergency flow; do not re-book. Every other doomed pin on a &#x60;p0&#x60; (out of area, missing skills, not a lead) still answers 409.  ⚠️ A SECOND carve-out, narrower: for a &#x60;p0&#x60;, a PERSONAL-CALENDAR overlap on the pinned technician is not refused here either — naming them is treated as having already phoned them — and the call answers 200 + &#x60;confirmed: true&#x60;. Nothing on this response discloses it; the only record is the business&#39;s activity feed (&#x60;job_calendar_override&#x60;). &#x60;calendar_busy&#x60;/&#x60;calendar_conflict&#x60; therefore never appear in the 409 reason vocabulary below when the pin is a &#x60;p0&#x60; naming a technician explicitly (this endpoint never books a crew, so the exclusion is unconditional here).  ⚠️ Otherwise, once the job is created it is never discarded, and the call answers 200 even if scheduling then fails: &#x60;confirmed: false&#x60; with &#x60;refusal&#x60; (stage + the exact error_code/data the quote or confirm endpoint would have returned, e.g. JOB_REQUEST_NO_TECHNICIAN_AVAILABLE with blockers). The job is then quoted and waiting in the coordinator&#39;s queue — tell the caller the office will confirm a time. Retry with the SAME Idempotency-Key to replay the result; a new key books a second job.  P0 dispatch: send &#x60;emergency&#x60; with &#x60;priority: \&quot;p0\&quot;&#x60;. &#x60;dispatch: \&quot;now\&quot;&#x60; plans the displacement cascade BEFORE anything is written — a refusal is a 409 creating nothing — then books, quotes and commits it. &#x60;dispatch: \&quot;later\&quot;&#x60; parks a quoted P0 in the tray and ignores the other fields.  ⚠️ &#x60;emergency.expected_move_ids&#x60; is REQUIRED with &#x60;dispatch: \&quot;now\&quot;&#x60; and has three meanings: omitted is refused, &#x60;[]&#x60; means \&quot;my preview showed no displacement\&quot; and commits a free lane, and a named set is the fence. Get the ids from previewEmergencyReschedule.  ⚠️ A refusal AFTER the job is created answers 200 with &#x60;confirmed: false&#x60; and &#x60;refusal.stage: \&quot;dispatch\&quot;&#x60;. Read &#x60;job_id&#x60;, re-preview with previewEmergencyReschedule and commit with commitEmergencyReschedule. Never re-book.
+    # @param job_request_book_and_confirm_request [JobRequestBookAndConfirmRequest] Book and confirm in one call
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_timezone Customer IANA timezone
-    # @return [Array<(CreateJobRequest200Response, Integer, Hash)>] CreateJobRequest200Response data, response status code and response headers
-    def create_job_request_with_http_info(job_request_create_request, opts = {})
+    # @option opts [String] :idempotency_key Makes retries safe: a repeat send with the same key returns the original result instead of booking again
+    # @return [Array<(BookAndConfirmJobRequest200Response, Integer, Hash)>] BookAndConfirmJobRequest200Response data, response status code and response headers
+    def book_and_confirm_job_request_with_http_info(job_request_book_and_confirm_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.create_job_request ...'
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.book_and_confirm_job_request ...'
       end
-      # verify the required parameter 'job_request_create_request' is set
-      if @api_client.config.client_side_validation && job_request_create_request.nil?
-        fail ArgumentError, "Missing the required parameter 'job_request_create_request' when calling JobRequestBusinessApi.create_job_request"
+      # verify the required parameter 'job_request_book_and_confirm_request' is set
+      if @api_client.config.client_side_validation && job_request_book_and_confirm_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_book_and_confirm_request' when calling JobRequestBusinessApi.book_and_confirm_job_request"
       end
       # resource path
-      local_var_path = '/job-requests'
+      local_var_path = '/job-requests/book-and-confirm'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -57,22 +59,22 @@ module Crisphive
       if !content_type.nil?
           header_params['Content-Type'] = content_type
       end
-      header_params[:'X-Timezone'] = opts[:'x_timezone'] if !opts[:'x_timezone'].nil?
+      header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_create_request)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_book_and_confirm_request)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'CreateJobRequest200Response'
+      return_type = opts[:debug_return_type] || 'BookAndConfirmJobRequest200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
 
       new_options = opts.merge(
-        :operation => :"JobRequestBusinessApi.create_job_request",
+        :operation => :"JobRequestBusinessApi.book_and_confirm_job_request",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -83,34 +85,38 @@ module Crisphive
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: JobRequestBusinessApi#create_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#book_and_confirm_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Get a job request
-    # @param id [String] Job request ID (UUID or short_code)
+    # Commit the previewed re-staffing of a technician's day
+    # Applies the plan returned by /absence/preview, ATOMICALLY: every assignment in one transaction (all or nothing), each job re-staffed onto its alternate at its unchanged window, its \"needs attention\" flag cleared, its status_version bumped. Commit VERIFIES and never re-solves — send `assignments[]` copied from `preview.resolved[]` (you may drop rows, never add or re-point them) and, to ACCEPT a priced alternative from `preview.unresolved[].alternatives[]`, the same row plus its `alternative_kind` and (for a reschedule kind) its `start_at`/`end_at`; the engine re-checks that technician at that window under exactly that relaxation. A reschedule kind rewrites `scheduled_at`, notifies the customer of the NEW TIME (`job_rescheduled`, never `tech_reassigned` on top) and fires `job_request.rescheduled`; the response row then carries `alternative_kind`, `cost`, `original_start_at`/`original_end_at` and `window_preserved: false`. Requires a time-off record covering EVERY day of the range for the technician (pending or approved); a pending one is APPROVED by the commit, because the engine's feasibility filter reads approved time-off only and without it the absent technician stays bookable everywhere else. The response mirrors the preview plus per-job `notification` evidence (dispatched | skipped + reason — what the routing WILL do, never proof of delivery), `attention_cleared`, and `time_off`. Supports Idempotency-Key. Requires job_manage AND schedule_manage (the approval is a scheduling action). See ABSENCE_RESOLVE_DESIGN.md. 409 NEXT STEPS: ABSENCE_RESOLVE_TIME_OFF_REQUIRED — the absence is not recorded well enough to commit against: `data.uncovered_dates[]` (days no eligible record touches) and `data.uncovered_jobs[]` (jobs no single eligible record spans); eligible = approved records, plus PENDING records whose span lies INSIDE the range — a pending record WIDER than the range (somebody's leave request) is never approved by this commit and is listed in `data.pending_wider_time_off_ids[]` for a human to decide. Record a sick-day time-off via `data.create_via` (POST /business/technician-time-off, pending is enough), then commit again. ABSENCE_RESOLVE_PLAN_DRIFTED — the world moved since the preview; `data.drifted[]` names the job (job_id/short_code/expected_version) and `reason` says how: `version` (the row changed or left the technician's lane), `infeasible` (the alternate can no longer take it), `occupied` (the alternate's lane overlapped after the write). No job was written; `data.time_offs[]` lists any pending record the commit had already approved — re-preview, show the new plan, commit again. ABSENCE_RESOLVE_NO_ORPHANED_JOBS — the board is empty for the range.
+    # @param job_request_absence_commit_request [JobRequestAbsenceCommitRequest] preview scope + the previewed assignments to apply
     # @param [Hash] opts the optional parameters
-    # @return [GetJobRequest200Response]
-    def get_job_request(id, opts = {})
-      data, _status_code, _headers = get_job_request_with_http_info(id, opts)
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [CommitAbsenceResolve200Response]
+    def commit_absence_resolve(job_request_absence_commit_request, opts = {})
+      data, _status_code, _headers = commit_absence_resolve_with_http_info(job_request_absence_commit_request, opts)
       data
     end
 
-    # Get a job request
-    # @param id [String] Job request ID (UUID or short_code)
+    # Commit the previewed re-staffing of a technician&#39;s day
+    # Applies the plan returned by /absence/preview, ATOMICALLY: every assignment in one transaction (all or nothing), each job re-staffed onto its alternate at its unchanged window, its \&quot;needs attention\&quot; flag cleared, its status_version bumped. Commit VERIFIES and never re-solves — send &#x60;assignments[]&#x60; copied from &#x60;preview.resolved[]&#x60; (you may drop rows, never add or re-point them) and, to ACCEPT a priced alternative from &#x60;preview.unresolved[].alternatives[]&#x60;, the same row plus its &#x60;alternative_kind&#x60; and (for a reschedule kind) its &#x60;start_at&#x60;/&#x60;end_at&#x60;; the engine re-checks that technician at that window under exactly that relaxation. A reschedule kind rewrites &#x60;scheduled_at&#x60;, notifies the customer of the NEW TIME (&#x60;job_rescheduled&#x60;, never &#x60;tech_reassigned&#x60; on top) and fires &#x60;job_request.rescheduled&#x60;; the response row then carries &#x60;alternative_kind&#x60;, &#x60;cost&#x60;, &#x60;original_start_at&#x60;/&#x60;original_end_at&#x60; and &#x60;window_preserved: false&#x60;. Requires a time-off record covering EVERY day of the range for the technician (pending or approved); a pending one is APPROVED by the commit, because the engine&#39;s feasibility filter reads approved time-off only and without it the absent technician stays bookable everywhere else. The response mirrors the preview plus per-job &#x60;notification&#x60; evidence (dispatched | skipped + reason — what the routing WILL do, never proof of delivery), &#x60;attention_cleared&#x60;, and &#x60;time_off&#x60;. Supports Idempotency-Key. Requires job_manage AND schedule_manage (the approval is a scheduling action). See ABSENCE_RESOLVE_DESIGN.md. 409 NEXT STEPS: ABSENCE_RESOLVE_TIME_OFF_REQUIRED — the absence is not recorded well enough to commit against: &#x60;data.uncovered_dates[]&#x60; (days no eligible record touches) and &#x60;data.uncovered_jobs[]&#x60; (jobs no single eligible record spans); eligible &#x3D; approved records, plus PENDING records whose span lies INSIDE the range — a pending record WIDER than the range (somebody&#39;s leave request) is never approved by this commit and is listed in &#x60;data.pending_wider_time_off_ids[]&#x60; for a human to decide. Record a sick-day time-off via &#x60;data.create_via&#x60; (POST /business/technician-time-off, pending is enough), then commit again. ABSENCE_RESOLVE_PLAN_DRIFTED — the world moved since the preview; &#x60;data.drifted[]&#x60; names the job (job_id/short_code/expected_version) and &#x60;reason&#x60; says how: &#x60;version&#x60; (the row changed or left the technician&#39;s lane), &#x60;infeasible&#x60; (the alternate can no longer take it), &#x60;occupied&#x60; (the alternate&#39;s lane overlapped after the write). No job was written; &#x60;data.time_offs[]&#x60; lists any pending record the commit had already approved — re-preview, show the new plan, commit again. ABSENCE_RESOLVE_NO_ORPHANED_JOBS — the board is empty for the range.
+    # @param job_request_absence_commit_request [JobRequestAbsenceCommitRequest] preview scope + the previewed assignments to apply
     # @param [Hash] opts the optional parameters
-    # @return [Array<(GetJobRequest200Response, Integer, Hash)>] GetJobRequest200Response data, response status code and response headers
-    def get_job_request_with_http_info(id, opts = {})
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [Array<(CommitAbsenceResolve200Response, Integer, Hash)>] CommitAbsenceResolve200Response data, response status code and response headers
+    def commit_absence_resolve_with_http_info(job_request_absence_commit_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.get_job_request ...'
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.commit_absence_resolve ...'
       end
-      # verify the required parameter 'id' is set
-      if @api_client.config.client_side_validation && id.nil?
-        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.get_job_request"
+      # verify the required parameter 'job_request_absence_commit_request' is set
+      if @api_client.config.client_side_validation && job_request_absence_commit_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_absence_commit_request' when calling JobRequestBusinessApi.commit_absence_resolve"
       end
       # resource path
-      local_var_path = '/job-requests/{id}'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+      local_var_path = '/job-requests/absence/commit'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -119,21 +125,27 @@ module Crisphive
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
       header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+      header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body]
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_absence_commit_request)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'GetJobRequest200Response'
+      return_type = opts[:debug_return_type] || 'CommitAbsenceResolve200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
 
       new_options = opts.merge(
-        :operation => :"JobRequestBusinessApi.get_job_request",
+        :operation => :"JobRequestBusinessApi.commit_absence_resolve",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -142,38 +154,117 @@ module Crisphive
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: JobRequestBusinessApi#get_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#commit_absence_resolve\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Commit emergency insert + cascade reschedule
+    # Applies the cascade previewed by /emergency/preview: assigns the emergency job to the technician and pushes the displaced jobs back (or, with `displacement_mode=reassign`, re-staffs them onto their previewed alternates first), atomically. Supports Idempotency-Key. The server recomputes the plan under a lock and fences each job on its status_version — if anything changed since the preview it returns 409 EMERGENCY_RESCHEDULE_PLAN_DRIFTED (re-preview). Same body as preview + optional `emergency_expected_version`. `after_hours_override=true` must match the preview it followed — it drops the non-working-day rejection (this endpoint never runs the technician's working-hours/time-off feasibility check; that only happens on /candidates), and the response carries an AFTER_HOURS warning; the committed job's activity feed also records who authorized the after-hours placement. Isolated feature (see EMERGENCY_RESCHEDULE_DESIGN.md). 409 NEXT STEPS: EMERGENCY_RESCHEDULE_PLAN_DRIFTED — the schedule changed between your preview and this commit (another booking/move won a lane); `data.drifted[]` names the job(s) whose status_version moved when the fence can attribute it (absent, never empty, when only a length mismatch is known): call /preview again, show the fresh plan, then commit. EMERGENCY_RESCHEDULE_SLOT_OCCUPIED — landing window blocked by an immovable anchor (P0/crew/multi-day); `data.conflicts[]` names it: another tech or time. Other codes — same remedies and `data` shapes as /candidates. EMERGENCY_RESCHEDULE_NO_WORKING_DAY fires on a closed day without after_hours_override and carries `data.override_available: true` — confirm with the coordinator, then retry with the flag.
+    # @param job_request_emergency_commit_request [JobRequestEmergencyCommitRequest] emergency insert spec
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [CommitEmergencyReschedule200Response]
+    def commit_emergency_reschedule(job_request_emergency_commit_request, opts = {})
+      data, _status_code, _headers = commit_emergency_reschedule_with_http_info(job_request_emergency_commit_request, opts)
+      data
+    end
+
+    # Commit emergency insert + cascade reschedule
+    # Applies the cascade previewed by /emergency/preview: assigns the emergency job to the technician and pushes the displaced jobs back (or, with &#x60;displacement_mode&#x3D;reassign&#x60;, re-staffs them onto their previewed alternates first), atomically. Supports Idempotency-Key. The server recomputes the plan under a lock and fences each job on its status_version — if anything changed since the preview it returns 409 EMERGENCY_RESCHEDULE_PLAN_DRIFTED (re-preview). Same body as preview + optional &#x60;emergency_expected_version&#x60;. &#x60;after_hours_override&#x3D;true&#x60; must match the preview it followed — it drops the non-working-day rejection (this endpoint never runs the technician&#39;s working-hours/time-off feasibility check; that only happens on /candidates), and the response carries an AFTER_HOURS warning; the committed job&#39;s activity feed also records who authorized the after-hours placement. Isolated feature (see EMERGENCY_RESCHEDULE_DESIGN.md). 409 NEXT STEPS: EMERGENCY_RESCHEDULE_PLAN_DRIFTED — the schedule changed between your preview and this commit (another booking/move won a lane); &#x60;data.drifted[]&#x60; names the job(s) whose status_version moved when the fence can attribute it (absent, never empty, when only a length mismatch is known): call /preview again, show the fresh plan, then commit. EMERGENCY_RESCHEDULE_SLOT_OCCUPIED — landing window blocked by an immovable anchor (P0/crew/multi-day); &#x60;data.conflicts[]&#x60; names it: another tech or time. Other codes — same remedies and &#x60;data&#x60; shapes as /candidates. EMERGENCY_RESCHEDULE_NO_WORKING_DAY fires on a closed day without after_hours_override and carries &#x60;data.override_available: true&#x60; — confirm with the coordinator, then retry with the flag.
+    # @param job_request_emergency_commit_request [JobRequestEmergencyCommitRequest] emergency insert spec
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [Array<(CommitEmergencyReschedule200Response, Integer, Hash)>] CommitEmergencyReschedule200Response data, response status code and response headers
+    def commit_emergency_reschedule_with_http_info(job_request_emergency_commit_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.commit_emergency_reschedule ...'
+      end
+      # verify the required parameter 'job_request_emergency_commit_request' is set
+      if @api_client.config.client_side_validation && job_request_emergency_commit_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_emergency_commit_request' when calling JobRequestBusinessApi.commit_emergency_reschedule"
+      end
+      # resource path
+      local_var_path = '/job-requests/emergency/commit'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+      header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_emergency_commit_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CommitEmergencyReschedule200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.commit_emergency_reschedule",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#commit_emergency_reschedule\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Job timeline (business surface — also serves tech via BusinessAuth)
-    # Per-status events[] composed from workflow snapshot + scattered typed cols + action_audit. FE renders as the Job Timeline panel (completed step = filled check, current = outline ring, upcoming = empty). entered_at nil for upcoming steps + older jobs missing the typed-col backfill.
+    # Commit a schedule-board job move
+    # Applies the move previewed by /move/preview: places the job on the technician at the new time and pushes the displaced jobs back, atomically (per-tech advisory lock; the server recomputes the plan and fences each job on its status_version — drift since the preview returns 409 SCHEDULE_MOVE_PLAN_DRIFTED, re-preview). Same body as preview + optional `expected_version`. See SCHEDULE_BOARD_DESIGN.md. 409 NEXT STEPS: SCHEDULE_MOVE_PLAN_DRIFTED — the schedule changed since your preview (or expected_move_ids/expected_member_ids no longer match): re-preview, show the fresh plan, commit again; carries no further `data` (the fence cannot attribute the drift to one specific job). All other codes — same remedies AND `data` shapes as /move/preview.
     # @param id [String] Job request ID (UUID or short_code)
+    # @param job_request_move_commit_req [JobRequestMoveCommitReq] move spec
     # @param [Hash] opts the optional parameters
-    # @return [GetJobRequestTimeline200Response]
-    def get_job_request_timeline(id, opts = {})
-      data, _status_code, _headers = get_job_request_timeline_with_http_info(id, opts)
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [CommitJobRequestMove200Response]
+    def commit_job_request_move(id, job_request_move_commit_req, opts = {})
+      data, _status_code, _headers = commit_job_request_move_with_http_info(id, job_request_move_commit_req, opts)
       data
     end
 
-    # Job timeline (business surface — also serves tech via BusinessAuth)
-    # Per-status events[] composed from workflow snapshot + scattered typed cols + action_audit. FE renders as the Job Timeline panel (completed step &#x3D; filled check, current &#x3D; outline ring, upcoming &#x3D; empty). entered_at nil for upcoming steps + older jobs missing the typed-col backfill.
+    # Commit a schedule-board job move
+    # Applies the move previewed by /move/preview: places the job on the technician at the new time and pushes the displaced jobs back, atomically (per-tech advisory lock; the server recomputes the plan and fences each job on its status_version — drift since the preview returns 409 SCHEDULE_MOVE_PLAN_DRIFTED, re-preview). Same body as preview + optional &#x60;expected_version&#x60;. See SCHEDULE_BOARD_DESIGN.md. 409 NEXT STEPS: SCHEDULE_MOVE_PLAN_DRIFTED — the schedule changed since your preview (or expected_move_ids/expected_member_ids no longer match): re-preview, show the fresh plan, commit again; carries no further &#x60;data&#x60; (the fence cannot attribute the drift to one specific job). All other codes — same remedies AND &#x60;data&#x60; shapes as /move/preview.
     # @param id [String] Job request ID (UUID or short_code)
+    # @param job_request_move_commit_req [JobRequestMoveCommitReq] move spec
     # @param [Hash] opts the optional parameters
-    # @return [Array<(GetJobRequestTimeline200Response, Integer, Hash)>] GetJobRequestTimeline200Response data, response status code and response headers
-    def get_job_request_timeline_with_http_info(id, opts = {})
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [Array<(CommitJobRequestMove200Response, Integer, Hash)>] CommitJobRequestMove200Response data, response status code and response headers
+    def commit_job_request_move_with_http_info(id, job_request_move_commit_req, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.get_job_request_timeline ...'
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.commit_job_request_move ...'
       end
       # verify the required parameter 'id' is set
       if @api_client.config.client_side_validation && id.nil?
-        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.get_job_request_timeline"
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.commit_job_request_move"
+      end
+      # verify the required parameter 'job_request_move_commit_req' is set
+      if @api_client.config.client_side_validation && job_request_move_commit_req.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_move_commit_req' when calling JobRequestBusinessApi.commit_job_request_move"
       end
       # resource path
-      local_var_path = '/job-requests/{id}/timeline'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+      local_var_path = '/job-requests/{id}/move/commit'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -182,21 +273,27 @@ module Crisphive
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
       header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+      header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body]
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_move_commit_req)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'GetJobRequestTimeline200Response'
+      return_type = opts[:debug_return_type] || 'CommitJobRequestMove200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
 
       new_options = opts.merge(
-        :operation => :"JobRequestBusinessApi.get_job_request_timeline",
+        :operation => :"JobRequestBusinessApi.commit_job_request_move",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -205,66 +302,75 @@ module Crisphive
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: JobRequestBusinessApi#get_job_request_timeline\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#commit_job_request_move\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Booking availability (business actor)
-    # @param x_timezone [String] Customer IANA timezone
+    # Confirm a booking on behalf of the customer
+    # Fires the customer-actor `confirm_booking` action from the BUSINESS surface (audited as business_on_behalf). Two uses: (1) LIVE — staff confirm a slot for a customer who booked by phone; (2) SANDBOX — the customer magic-token surface is live-only (a sandbox job's link can never reach a real customer), so this is the ONLY way to drive a sandbox test job past booking (book → quote → confirm → assign → complete). Body carries the customer-chosen scheduled_at (business-local naive datetime). DECISION TABLE — every 409 this endpoint returns, and the correct NEXT STEP (branch on error_code, never on the HTTP status): • JOB_REQUEST_STAGE_CONFLICT — the job changed since you read it (NOTE: every FAILED confirm attempt also bumps status_version by design). Next: re-GET the job, retry with the fresh status_version. • JOB_REQUEST_ACTION_NOT_PENDING — the job is no longer at the confirm step (usually: already confirmed). Next: re-GET and show current status; do not retry. • JOB_REQUEST_NO_TECHNICIAN_AVAILABLE — the TIME is infeasible for everyone (outside working hours / the customer window, or nobody qualifies). Best-effort `data` breakdown: `considered` (roster size checked), `blocked_by` (histogram of blockers[0].kind → count, only kinds that actually blocked someone), `truncated` (roster larger than the check covered). Next: pick another time via booking-windows / time-segments. NOT an emergency case — displacement cannot conjure capacity. • JOB_REQUEST_TECH_INFEASIBLE — the FORCED technician cannot take the job then; `data.reason` says why (blockers[0].kind): outside_service_area | missing_required_skills | not_lead_tier | no_working_day | on_time_off | off_shift | calendar_busy | calendar_conflict | visit_too_long | occupied (they are already working then — `data.earliest_feasible_at` is when they are free) | cannot_arrive_in_time (see `data.earliest_feasible_at`, RFC3339 UTC — the first same-day time they CAN be on site → offer it) | not_available_today (diagnosis unavailable). `data.blockers[]` names EVERY cause, most-structural first; `data.technician` carries `{id, name}`, name best-effort (empty only when the lookup itself could not resolve) — EXCEPT on not_lead_tier, which carries a flat `data.technician_id` and no technician object. A UI that reads only `reason` still works. Next: keep the tech and reschedule to earliest_feasible_at+, OR keep the time and drop technician_id (auto-pick) / choose another tech from time-segments. NOT an emergency case. • JOB_REQUEST_P0_REQUIRES_DISPLACEMENT — the ONLY code that routes to the EMERGENCY flow: the job is P0, the tech qualifies, but the lane is genuinely occupied. Next: POST emergency/candidates → preview → commit (the commit auto-confirms). Caveat: if the occupying jobs are themselves P0 the preview will reject with EMERGENCY_RESCHEDULE_SLOT_OCCUPIED (P0 never displaces P0) — then pick another tech/time.
+    # @param id [String] Job request ID
+    # @param job_request_confirm_request [JobRequestConfirmRequest] Chosen slot (scheduled_at) + optional technician_id force-assign (P0–P3 flow: pins the ranked candidate, feasibility still enforced)
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :from Start YYYY-MM-DD
-    # @option opts [String] :to End YYYY-MM-DD
-    # @return [ListJobRequestBookingWindows200Response]
-    def list_job_request_booking_windows(x_timezone, opts = {})
-      data, _status_code, _headers = list_job_request_booking_windows_with_http_info(x_timezone, opts)
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [ResponseEnvelope]
+    def confirm_job_request(id, job_request_confirm_request, opts = {})
+      data, _status_code, _headers = confirm_job_request_with_http_info(id, job_request_confirm_request, opts)
       data
     end
 
-    # Booking availability (business actor)
-    # @param x_timezone [String] Customer IANA timezone
+    # Confirm a booking on behalf of the customer
+    # Fires the customer-actor &#x60;confirm_booking&#x60; action from the BUSINESS surface (audited as business_on_behalf). Two uses: (1) LIVE — staff confirm a slot for a customer who booked by phone; (2) SANDBOX — the customer magic-token surface is live-only (a sandbox job&#39;s link can never reach a real customer), so this is the ONLY way to drive a sandbox test job past booking (book → quote → confirm → assign → complete). Body carries the customer-chosen scheduled_at (business-local naive datetime). DECISION TABLE — every 409 this endpoint returns, and the correct NEXT STEP (branch on error_code, never on the HTTP status): • JOB_REQUEST_STAGE_CONFLICT — the job changed since you read it (NOTE: every FAILED confirm attempt also bumps status_version by design). Next: re-GET the job, retry with the fresh status_version. • JOB_REQUEST_ACTION_NOT_PENDING — the job is no longer at the confirm step (usually: already confirmed). Next: re-GET and show current status; do not retry. • JOB_REQUEST_NO_TECHNICIAN_AVAILABLE — the TIME is infeasible for everyone (outside working hours / the customer window, or nobody qualifies). Best-effort &#x60;data&#x60; breakdown: &#x60;considered&#x60; (roster size checked), &#x60;blocked_by&#x60; (histogram of blockers[0].kind → count, only kinds that actually blocked someone), &#x60;truncated&#x60; (roster larger than the check covered). Next: pick another time via booking-windows / time-segments. NOT an emergency case — displacement cannot conjure capacity. • JOB_REQUEST_TECH_INFEASIBLE — the FORCED technician cannot take the job then; &#x60;data.reason&#x60; says why (blockers[0].kind): outside_service_area | missing_required_skills | not_lead_tier | no_working_day | on_time_off | off_shift | calendar_busy | calendar_conflict | visit_too_long | occupied (they are already working then — &#x60;data.earliest_feasible_at&#x60; is when they are free) | cannot_arrive_in_time (see &#x60;data.earliest_feasible_at&#x60;, RFC3339 UTC — the first same-day time they CAN be on site → offer it) | not_available_today (diagnosis unavailable). &#x60;data.blockers[]&#x60; names EVERY cause, most-structural first; &#x60;data.technician&#x60; carries &#x60;{id, name}&#x60;, name best-effort (empty only when the lookup itself could not resolve) — EXCEPT on not_lead_tier, which carries a flat &#x60;data.technician_id&#x60; and no technician object. A UI that reads only &#x60;reason&#x60; still works. Next: keep the tech and reschedule to earliest_feasible_at+, OR keep the time and drop technician_id (auto-pick) / choose another tech from time-segments. NOT an emergency case. • JOB_REQUEST_P0_REQUIRES_DISPLACEMENT — the ONLY code that routes to the EMERGENCY flow: the job is P0, the tech qualifies, but the lane is genuinely occupied. Next: POST emergency/candidates → preview → commit (the commit auto-confirms). Caveat: if the occupying jobs are themselves P0 the preview will reject with EMERGENCY_RESCHEDULE_SLOT_OCCUPIED (P0 never displaces P0) — then pick another tech/time.
+    # @param id [String] Job request ID
+    # @param job_request_confirm_request [JobRequestConfirmRequest] Chosen slot (scheduled_at) + optional technician_id force-assign (P0–P3 flow: pins the ranked candidate, feasibility still enforced)
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :from Start YYYY-MM-DD
-    # @option opts [String] :to End YYYY-MM-DD
-    # @return [Array<(ListJobRequestBookingWindows200Response, Integer, Hash)>] ListJobRequestBookingWindows200Response data, response status code and response headers
-    def list_job_request_booking_windows_with_http_info(x_timezone, opts = {})
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key replays the original response (header Idempotent-Replayed: true) instead of re-running the operation. Reusing a key with a different body returns 422 IDEMPOTENCY_KEY_REUSE.
+    # @return [Array<(ResponseEnvelope, Integer, Hash)>] ResponseEnvelope data, response status code and response headers
+    def confirm_job_request_with_http_info(id, job_request_confirm_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_job_request_booking_windows ...'
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.confirm_job_request ...'
       end
-      # verify the required parameter 'x_timezone' is set
-      if @api_client.config.client_side_validation && x_timezone.nil?
-        fail ArgumentError, "Missing the required parameter 'x_timezone' when calling JobRequestBusinessApi.list_job_request_booking_windows"
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.confirm_job_request"
+      end
+      # verify the required parameter 'job_request_confirm_request' is set
+      if @api_client.config.client_side_validation && job_request_confirm_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_confirm_request' when calling JobRequestBusinessApi.confirm_job_request"
       end
       # resource path
-      local_var_path = '/job-requests/booking-windows'
+      local_var_path = '/job-requests/{id}/confirm'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
-      query_params[:'from'] = opts[:'from'] if !opts[:'from'].nil?
-      query_params[:'to'] = opts[:'to'] if !opts[:'to'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
       header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Timezone'] = x_timezone
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+      header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body]
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_confirm_request)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'ListJobRequestBookingWindows200Response'
+      return_type = opts[:debug_return_type] || 'ResponseEnvelope'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
 
       new_options = opts.merge(
-        :operation => :"JobRequestBusinessApi.list_job_request_booking_windows",
+        :operation => :"JobRequestBusinessApi.confirm_job_request",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -273,79 +379,72 @@ module Crisphive
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_job_request_booking_windows\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#confirm_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Poll for new & changed job requests (sync feed)
-    # Keep your own copy of bookings in sync WITHOUT re-listing everything: returns the job requests whose state changed (created, status transition, reschedule, soft-delete/archive) at or after the `since` cursor, ordered oldest-change-first (updated_at ASC).  How to use it: (1) On your first poll OMIT `since` — the server primes the cursor at \"now\", returns no items and a `next_since`. (2) Store `next_since` and pass it as `since` on the next poll. (3) Apply each returned item to your store by UPSERTING on `id` (the server re-scans a ~5s safety window, so the same job may appear again — never blindly append). (4) If `has_more` is true the page filled to `limit` and more changes are already waiting — poll again immediately; otherwise wait your normal interval (e.g. 5–15s).  This is NOT pagination — it is a time-keyed change feed. Use the paginated GET /job-requests for the initial bulk load, then this endpoint to stay live. Filters (status_keys, customer_id, …) narrow the feed to the slice you care about.
+    # Create a job request
+    # Books a field-operations job — the work order that enters the dispatch & scheduling pipeline. Send the customer's UUID plus requested `job_dates` (date + morning/afternoon/evening periods, ideally offered from GET /job-requests/booking-windows), optional `job_type_id` (service catalog), `skill_ids` (required technician qualifications) and a free-text description. Quoting, technician/crew assignment and completion then advance the work order through the business's workflow.
+    # @param job_request_create_request [JobRequestCreateRequest] Booking payload
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :status_keys Comma-separated status slugs — only surface changes to jobs in these statuses
-    # @option opts [String] :priority Priority filter (normal|emergency)
-    # @option opts [String] :customer_id Only changes to this customer&#39;s jobs (UUID)
-    # @option opts [String] :technician_id Only changes to jobs assigned to this technician (UUID)
-    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD or RFC3339); range is [from, to)
-    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD or RFC3339), exclusive
-    # @option opts [String] :since RFC3339 cursor from the prior response&#39;s next_since. OMIT on the first poll to prime the cursor at server-now.
-    # @option opts [Integer] :limit Max changes per poll (default 15, max 1000). If the page fills, has_more&#x3D;true.
-    # @return [ListJobRequestChanges200Response]
-    def list_job_request_changes(opts = {})
-      data, _status_code, _headers = list_job_request_changes_with_http_info(opts)
+    # @option opts [String] :x_timezone Customer IANA timezone
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key returns the original booking instead of creating a duplicate
+    # @return [CreateJobRequest200Response]
+    def create_job_request(job_request_create_request, opts = {})
+      data, _status_code, _headers = create_job_request_with_http_info(job_request_create_request, opts)
       data
     end
 
-    # Poll for new &amp; changed job requests (sync feed)
-    # Keep your own copy of bookings in sync WITHOUT re-listing everything: returns the job requests whose state changed (created, status transition, reschedule, soft-delete/archive) at or after the &#x60;since&#x60; cursor, ordered oldest-change-first (updated_at ASC).  How to use it: (1) On your first poll OMIT &#x60;since&#x60; — the server primes the cursor at \&quot;now\&quot;, returns no items and a &#x60;next_since&#x60;. (2) Store &#x60;next_since&#x60; and pass it as &#x60;since&#x60; on the next poll. (3) Apply each returned item to your store by UPSERTING on &#x60;id&#x60; (the server re-scans a ~5s safety window, so the same job may appear again — never blindly append). (4) If &#x60;has_more&#x60; is true the page filled to &#x60;limit&#x60; and more changes are already waiting — poll again immediately; otherwise wait your normal interval (e.g. 5–15s).  This is NOT pagination — it is a time-keyed change feed. Use the paginated GET /job-requests for the initial bulk load, then this endpoint to stay live. Filters (status_keys, customer_id, …) narrow the feed to the slice you care about.
+    # Create a job request
+    # Books a field-operations job — the work order that enters the dispatch &amp; scheduling pipeline. Send the customer&#39;s UUID plus requested &#x60;job_dates&#x60; (date + morning/afternoon/evening periods, ideally offered from GET /job-requests/booking-windows), optional &#x60;job_type_id&#x60; (service catalog), &#x60;skill_ids&#x60; (required technician qualifications) and a free-text description. Quoting, technician/crew assignment and completion then advance the work order through the business&#39;s workflow.
+    # @param job_request_create_request [JobRequestCreateRequest] Booking payload
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :status_keys Comma-separated status slugs — only surface changes to jobs in these statuses
-    # @option opts [String] :priority Priority filter (normal|emergency)
-    # @option opts [String] :customer_id Only changes to this customer&#39;s jobs (UUID)
-    # @option opts [String] :technician_id Only changes to jobs assigned to this technician (UUID)
-    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD or RFC3339); range is [from, to)
-    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD or RFC3339), exclusive
-    # @option opts [String] :since RFC3339 cursor from the prior response&#39;s next_since. OMIT on the first poll to prime the cursor at server-now.
-    # @option opts [Integer] :limit Max changes per poll (default 15, max 1000). If the page fills, has_more&#x3D;true.
-    # @return [Array<(ListJobRequestChanges200Response, Integer, Hash)>] ListJobRequestChanges200Response data, response status code and response headers
-    def list_job_request_changes_with_http_info(opts = {})
+    # @option opts [String] :x_timezone Customer IANA timezone
+    # @option opts [String] :idempotency_key Unique key making retries safe: a repeat send with the same key returns the original booking instead of creating a duplicate
+    # @return [Array<(CreateJobRequest200Response, Integer, Hash)>] CreateJobRequest200Response data, response status code and response headers
+    def create_job_request_with_http_info(job_request_create_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_job_request_changes ...'
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.create_job_request ...'
+      end
+      # verify the required parameter 'job_request_create_request' is set
+      if @api_client.config.client_side_validation && job_request_create_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_create_request' when calling JobRequestBusinessApi.create_job_request"
       end
       # resource path
-      local_var_path = '/job-requests/changes'
+      local_var_path = '/job-requests'
 
       # query parameters
       query_params = opts[:query_params] || {}
-      query_params[:'status_keys'] = opts[:'status_keys'] if !opts[:'status_keys'].nil?
-      query_params[:'priority'] = opts[:'priority'] if !opts[:'priority'].nil?
-      query_params[:'customer_id'] = opts[:'customer_id'] if !opts[:'customer_id'].nil?
-      query_params[:'technician_id'] = opts[:'technician_id'] if !opts[:'technician_id'].nil?
-      query_params[:'scheduled_from'] = opts[:'scheduled_from'] if !opts[:'scheduled_from'].nil?
-      query_params[:'scheduled_to'] = opts[:'scheduled_to'] if !opts[:'scheduled_to'].nil?
-      query_params[:'since'] = opts[:'since'] if !opts[:'since'].nil?
-      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
       header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+      header_params[:'X-Timezone'] = opts[:'x_timezone'] if !opts[:'x_timezone'].nil?
+      header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body]
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_create_request)
 
       # return_type
-      return_type = opts[:debug_return_type] || 'ListJobRequestChanges200Response'
+      return_type = opts[:debug_return_type] || 'CreateJobRequest200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
 
       new_options = opts.merge(
-        :operation => :"JobRequestBusinessApi.list_job_request_changes",
+        :operation => :"JobRequestBusinessApi.create_job_request",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -354,63 +453,41 @@ module Crisphive
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_job_request_changes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#create_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # List job requests
+    # Get a job request
+    # Returns the full work order: current workflow status, quoted duration, confirmed schedule, customer contact snapshot and the assigned technician / crew — everything a dispatcher or an external field-operations system needs to track one job.
+    # @param id [String] Job request ID (UUID or short_code)
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :status_keys Comma-separated status slugs
-    # @option opts [String] :status active (default) | archived | all
-    # @option opts [String] :customer_id Customer UUID
-    # @option opts [String] :technician_id Technician UUID
-    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD or RFC3339); range is [from, to)
-    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD or RFC3339), exclusive
-    # @option opts [String] :q Search short_code or description (case-insensitive, partial match)
-    # @option opts [String] :sort Sort key
-    # @option opts [Integer] :page Page number
-    # @option opts [Integer] :limit Page size
-    # @return [ListJobRequests200Response]
-    def list_job_requests(opts = {})
-      data, _status_code, _headers = list_job_requests_with_http_info(opts)
+    # @return [GetJobRequest200Response]
+    def get_job_request(id, opts = {})
+      data, _status_code, _headers = get_job_request_with_http_info(id, opts)
       data
     end
 
-    # List job requests
+    # Get a job request
+    # Returns the full work order: current workflow status, quoted duration, confirmed schedule, customer contact snapshot and the assigned technician / crew — everything a dispatcher or an external field-operations system needs to track one job.
+    # @param id [String] Job request ID (UUID or short_code)
     # @param [Hash] opts the optional parameters
-    # @option opts [String] :status_keys Comma-separated status slugs
-    # @option opts [String] :status active (default) | archived | all
-    # @option opts [String] :customer_id Customer UUID
-    # @option opts [String] :technician_id Technician UUID
-    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD or RFC3339); range is [from, to)
-    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD or RFC3339), exclusive
-    # @option opts [String] :q Search short_code or description (case-insensitive, partial match)
-    # @option opts [String] :sort Sort key
-    # @option opts [Integer] :page Page number
-    # @option opts [Integer] :limit Page size
-    # @return [Array<(ListJobRequests200Response, Integer, Hash)>] ListJobRequests200Response data, response status code and response headers
-    def list_job_requests_with_http_info(opts = {})
+    # @return [Array<(GetJobRequest200Response, Integer, Hash)>] GetJobRequest200Response data, response status code and response headers
+    def get_job_request_with_http_info(id, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_job_requests ...'
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.get_job_request ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.get_job_request"
       end
       # resource path
-      local_var_path = '/job-requests'
+      local_var_path = '/job-requests/{id}'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
-      query_params[:'status_keys'] = opts[:'status_keys'] if !opts[:'status_keys'].nil?
-      query_params[:'status'] = opts[:'status'] if !opts[:'status'].nil?
-      query_params[:'customer_id'] = opts[:'customer_id'] if !opts[:'customer_id'].nil?
-      query_params[:'technician_id'] = opts[:'technician_id'] if !opts[:'technician_id'].nil?
-      query_params[:'scheduled_from'] = opts[:'scheduled_from'] if !opts[:'scheduled_from'].nil?
-      query_params[:'scheduled_to'] = opts[:'scheduled_to'] if !opts[:'scheduled_to'].nil?
-      query_params[:'q'] = opts[:'q'] if !opts[:'q'].nil?
-      query_params[:'sort'] = opts[:'sort'] if !opts[:'sort'].nil?
-      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
-      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -424,13 +501,13 @@ module Crisphive
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'ListJobRequests200Response'
+      return_type = opts[:debug_return_type] || 'GetJobRequest200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
 
       new_options = opts.merge(
-        :operation => :"JobRequestBusinessApi.list_job_requests",
+        :operation => :"JobRequestBusinessApi.get_job_request",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -441,7 +518,1036 @@ module Crisphive
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_job_requests\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#get_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Job timeline
+    # Per-status progress of a job's lifecycle (e.g. booked → confirmed → on the way → arrived → completed, following the business's configured workflow) — render it as a job-tracking timeline. Each status carries its state (completed | current | upcoming), when the job entered it, and the actions fired within it. entered_at may be null for upcoming steps and for older jobs predating the backfill.
+    # @param id [String] Job request ID (UUID or short_code)
+    # @param [Hash] opts the optional parameters
+    # @return [GetJobRequestTimeline200Response]
+    def get_job_request_timeline(id, opts = {})
+      data, _status_code, _headers = get_job_request_timeline_with_http_info(id, opts)
+      data
+    end
+
+    # Job timeline
+    # Per-status progress of a job&#39;s lifecycle (e.g. booked → confirmed → on the way → arrived → completed, following the business&#39;s configured workflow) — render it as a job-tracking timeline. Each status carries its state (completed | current | upcoming), when the job entered it, and the actions fired within it. entered_at may be null for upcoming steps and for older jobs predating the backfill.
+    # @param id [String] Job request ID (UUID or short_code)
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(GetJobRequestTimeline200Response, Integer, Hash)>] GetJobRequestTimeline200Response data, response status code and response headers
+    def get_job_request_timeline_with_http_info(id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.get_job_request_timeline ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.get_job_request_timeline"
+      end
+      # resource path
+      local_var_path = '/job-requests/{id}/timeline'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'GetJobRequestTimeline200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.get_job_request_timeline",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#get_job_request_timeline\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # One technician's real schedule (sessions + time off)
+    # The technician's ACTUAL occupancy over a date range: every job session on their lane (solo/lead and crew) plus approved time-off blocks. Weekly recurring working hours come from the technician-availability endpoints — combine both for the full availability picture (\"get crew availability\"). from/to are business-local dates (YYYY-MM-DD, inclusive); omitted = today .. +7 days; range max 31 days.
+    # @param id [String] Technician ID
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :from Start date (YYYY-MM-DD, business-local; default today)
+    # @option opts [String] :to End date (YYYY-MM-DD, inclusive; default from+7d; max range 31 days)
+    # @return [GetTechnicianSchedule200Response]
+    def get_technician_schedule(id, opts = {})
+      data, _status_code, _headers = get_technician_schedule_with_http_info(id, opts)
+      data
+    end
+
+    # One technician&#39;s real schedule (sessions + time off)
+    # The technician&#39;s ACTUAL occupancy over a date range: every job session on their lane (solo/lead and crew) plus approved time-off blocks. Weekly recurring working hours come from the technician-availability endpoints — combine both for the full availability picture (\&quot;get crew availability\&quot;). from/to are business-local dates (YYYY-MM-DD, inclusive); omitted &#x3D; today .. +7 days; range max 31 days.
+    # @param id [String] Technician ID
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :from Start date (YYYY-MM-DD, business-local; default today)
+    # @option opts [String] :to End date (YYYY-MM-DD, inclusive; default from+7d; max range 31 days)
+    # @return [Array<(GetTechnicianSchedule200Response, Integer, Hash)>] GetTechnicianSchedule200Response data, response status code and response headers
+    def get_technician_schedule_with_http_info(id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.get_technician_schedule ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.get_technician_schedule"
+      end
+      # resource path
+      local_var_path = '/technicians/{id}/schedule'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'from'] = opts[:'from'] if !opts[:'from'].nil?
+      query_params[:'to'] = opts[:'to'] if !opts[:'to'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'GetTechnicianSchedule200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.get_technician_schedule",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#get_technician_schedule\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Matching crew candidates for a job
+    # RE-STAFFING candidates for a CONFIRMED, SCHEDULED job (not yet completed/archived) — any earlier or later stage returns 409 JOB_REQUEST_INVALID_TRANSITION. This is the pool of technicians who could REPLACE the current crew: the currently assigned lead and buddies are deliberately excluded (they are the status quo, not an option), so on a small roster an empty `leads` list is a normal answer, not an error. For pre-booking discovery (\"who could take this job before it is confirmed?\") use listJobRequestBookingWindows / listMatchingSlots / the time-segments grid instead. Candidates are matched and ranked by the smart-assignment engine — skills per crew slot, weekly availability, existing schedule, time off and travel are all checked; each carries a score breakdown (distance, travel, matched skills) plus the exact on-site session plan they would work. NOT a raw roster list (use GET /technicians for that). Returns the ranked feasible LEAD pool by default; pass include_buddies=true to also return per-slot buddy pools, include_vehicle=true to include the available-vehicle list. force_lead_id checks one specific technician: returns only that lead (with their crew combo) if feasible, else 409 JOB_REQUEST_NO_TECHNICIAN_AVAILABLE.
+    # @param id [String] Job request ID or short_code
+    # @param [Hash] opts the optional parameters
+    # @option opts [Boolean] :include_buddies Also return buddy candidate pools
+    # @option opts [Boolean] :include_vehicle Also return the available-vehicle list
+    # @option opts [String] :force_lead_id Check a specific technician as lead — returns only that lead if feasible, else 409
+    # @return [ListCrewCandidates200Response]
+    def list_crew_candidates(id, opts = {})
+      data, _status_code, _headers = list_crew_candidates_with_http_info(id, opts)
+      data
+    end
+
+    # Matching crew candidates for a job
+    # RE-STAFFING candidates for a CONFIRMED, SCHEDULED job (not yet completed/archived) — any earlier or later stage returns 409 JOB_REQUEST_INVALID_TRANSITION. This is the pool of technicians who could REPLACE the current crew: the currently assigned lead and buddies are deliberately excluded (they are the status quo, not an option), so on a small roster an empty &#x60;leads&#x60; list is a normal answer, not an error. For pre-booking discovery (\&quot;who could take this job before it is confirmed?\&quot;) use listJobRequestBookingWindows / listMatchingSlots / the time-segments grid instead. Candidates are matched and ranked by the smart-assignment engine — skills per crew slot, weekly availability, existing schedule, time off and travel are all checked; each carries a score breakdown (distance, travel, matched skills) plus the exact on-site session plan they would work. NOT a raw roster list (use GET /technicians for that). Returns the ranked feasible LEAD pool by default; pass include_buddies&#x3D;true to also return per-slot buddy pools, include_vehicle&#x3D;true to include the available-vehicle list. force_lead_id checks one specific technician: returns only that lead (with their crew combo) if feasible, else 409 JOB_REQUEST_NO_TECHNICIAN_AVAILABLE.
+    # @param id [String] Job request ID or short_code
+    # @param [Hash] opts the optional parameters
+    # @option opts [Boolean] :include_buddies Also return buddy candidate pools
+    # @option opts [Boolean] :include_vehicle Also return the available-vehicle list
+    # @option opts [String] :force_lead_id Check a specific technician as lead — returns only that lead if feasible, else 409
+    # @return [Array<(ListCrewCandidates200Response, Integer, Hash)>] ListCrewCandidates200Response data, response status code and response headers
+    def list_crew_candidates_with_http_info(id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_crew_candidates ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.list_crew_candidates"
+      end
+      # resource path
+      local_var_path = '/job-requests/{id}/crew-candidates'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'include_buddies'] = opts[:'include_buddies'] if !opts[:'include_buddies'].nil?
+      query_params[:'include_vehicle'] = opts[:'include_vehicle'] if !opts[:'include_vehicle'].nil?
+      query_params[:'force_lead_id'] = opts[:'force_lead_id'] if !opts[:'force_lead_id'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListCrewCandidates200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_crew_candidates",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_crew_candidates\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Rank technicians for a P0 emergency insert
+    # Returns the technicians who could take the emergency job at the requested start, ranked FASTEST-ARRIVAL first (arrival beats route efficiency for a P0). The response also carries a historical `crew_recommendation` (median crew size on comparable completed jobs + mandatory disclaimer — AC-2). Booked technicians are still candidates — each entry carries the displacement preview (which lower-priority jobs would be pushed, per day) that committing to them would cause; total_moves=0 means a free slot. P0 jobs are never displaced; P1 only by a P0. ETA is estimated from the technician's start location (no live GPS). `after_hours_override=true` — the coordinator has phoned the technician — drops the non-working-day rejection AND each candidate's working-hours/time-off feasibility check; an affected candidate carries a per-technician TIME_OFF_OVERLAP warning instead. This is THE phone list for an after-hours insert: it ranks even on a day with no working hours once the flag is set. Feed the chosen technician_id into emergency/preview + emergency/commit. 409 NEXT STEPS: EMERGENCY_RESCHEDULE_NOT_ELIGIBLE — the job cannot be emergency-inserted; `data.failed_precondition` names which (not_quoted | archived | completed | not_p0 | smart_assign_unavailable): fix the job state or use a normal confirm. EMERGENCY_RESCHEDULE_CREW_UNSUPPORTED — crew jobs cannot use the emergency flow (v1, `data.crew_size` = lead + buddies): staff via confirm/reassign instead. EMERGENCY_RESCHEDULE_MULTIDAY_UNSUPPORTED — either a confirmed multi-day job (`data.session_count`/`data.session_dates`; use the normal reassign flow) or a single visit longer than the structural span bound, in which case `data.reason=visit_too_long` + `data.blockers[0]` (visit_minutes/max_minutes) name it — no remedy but a shorter visit. EMERGENCY_RESCHEDULE_NO_WORKING_DAY — the chosen date has no working hours (`data.business_timezone`/`data.requested_weekday`): pick a working day, or set after_hours_override=true (the coordinator has phoned someone) to rank candidates anyway. EMERGENCY_RESCHEDULE_IN_PAST — start time already passed: pick a future time; `data` carries the timezone the naive start_at was read in (`business_timezone`) plus the instant it resolved to, so a start that looks future on the caller's own clock can be diagnosed without guessing.
+    # @param job_request_emergency_candidates_request [JobRequestEmergencyCandidatesRequest] Emergency job + desired start
+    # @param [Hash] opts the optional parameters
+    # @return [ListEmergencyCandidates200Response]
+    def list_emergency_candidates(job_request_emergency_candidates_request, opts = {})
+      data, _status_code, _headers = list_emergency_candidates_with_http_info(job_request_emergency_candidates_request, opts)
+      data
+    end
+
+    # Rank technicians for a P0 emergency insert
+    # Returns the technicians who could take the emergency job at the requested start, ranked FASTEST-ARRIVAL first (arrival beats route efficiency for a P0). The response also carries a historical &#x60;crew_recommendation&#x60; (median crew size on comparable completed jobs + mandatory disclaimer — AC-2). Booked technicians are still candidates — each entry carries the displacement preview (which lower-priority jobs would be pushed, per day) that committing to them would cause; total_moves&#x3D;0 means a free slot. P0 jobs are never displaced; P1 only by a P0. ETA is estimated from the technician&#39;s start location (no live GPS). &#x60;after_hours_override&#x3D;true&#x60; — the coordinator has phoned the technician — drops the non-working-day rejection AND each candidate&#39;s working-hours/time-off feasibility check; an affected candidate carries a per-technician TIME_OFF_OVERLAP warning instead. This is THE phone list for an after-hours insert: it ranks even on a day with no working hours once the flag is set. Feed the chosen technician_id into emergency/preview + emergency/commit. 409 NEXT STEPS: EMERGENCY_RESCHEDULE_NOT_ELIGIBLE — the job cannot be emergency-inserted; &#x60;data.failed_precondition&#x60; names which (not_quoted | archived | completed | not_p0 | smart_assign_unavailable): fix the job state or use a normal confirm. EMERGENCY_RESCHEDULE_CREW_UNSUPPORTED — crew jobs cannot use the emergency flow (v1, &#x60;data.crew_size&#x60; &#x3D; lead + buddies): staff via confirm/reassign instead. EMERGENCY_RESCHEDULE_MULTIDAY_UNSUPPORTED — either a confirmed multi-day job (&#x60;data.session_count&#x60;/&#x60;data.session_dates&#x60;; use the normal reassign flow) or a single visit longer than the structural span bound, in which case &#x60;data.reason&#x3D;visit_too_long&#x60; + &#x60;data.blockers[0]&#x60; (visit_minutes/max_minutes) name it — no remedy but a shorter visit. EMERGENCY_RESCHEDULE_NO_WORKING_DAY — the chosen date has no working hours (&#x60;data.business_timezone&#x60;/&#x60;data.requested_weekday&#x60;): pick a working day, or set after_hours_override&#x3D;true (the coordinator has phoned someone) to rank candidates anyway. EMERGENCY_RESCHEDULE_IN_PAST — start time already passed: pick a future time; &#x60;data&#x60; carries the timezone the naive start_at was read in (&#x60;business_timezone&#x60;) plus the instant it resolved to, so a start that looks future on the caller&#39;s own clock can be diagnosed without guessing.
+    # @param job_request_emergency_candidates_request [JobRequestEmergencyCandidatesRequest] Emergency job + desired start
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(ListEmergencyCandidates200Response, Integer, Hash)>] ListEmergencyCandidates200Response data, response status code and response headers
+    def list_emergency_candidates_with_http_info(job_request_emergency_candidates_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_emergency_candidates ...'
+      end
+      # verify the required parameter 'job_request_emergency_candidates_request' is set
+      if @api_client.config.client_side_validation && job_request_emergency_candidates_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_emergency_candidates_request' when calling JobRequestBusinessApi.list_emergency_candidates"
+      end
+      # resource path
+      local_var_path = '/job-requests/emergency/candidates'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_emergency_candidates_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListEmergencyCandidates200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_emergency_candidates",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_emergency_candidates\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Booking availability
+    # Real-time appointment availability from the scheduling engine: returns the bookable date + time-period windows given technician capacity, working hours and service-territory coverage. Call this before creating a job request and offer the customer ONLY the returned windows — it prevents unschedulable bookings.
+    # @param x_timezone [String] Customer IANA timezone
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :from Start YYYY-MM-DD
+    # @option opts [String] :to End YYYY-MM-DD
+    # @return [ListJobRequestBookingWindows200Response]
+    def list_job_request_booking_windows(x_timezone, opts = {})
+      data, _status_code, _headers = list_job_request_booking_windows_with_http_info(x_timezone, opts)
+      data
+    end
+
+    # Booking availability
+    # Real-time appointment availability from the scheduling engine: returns the bookable date + time-period windows given technician capacity, working hours and service-territory coverage. Call this before creating a job request and offer the customer ONLY the returned windows — it prevents unschedulable bookings.
+    # @param x_timezone [String] Customer IANA timezone
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :from Start YYYY-MM-DD
+    # @option opts [String] :to End YYYY-MM-DD
+    # @return [Array<(ListJobRequestBookingWindows200Response, Integer, Hash)>] ListJobRequestBookingWindows200Response data, response status code and response headers
+    def list_job_request_booking_windows_with_http_info(x_timezone, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_job_request_booking_windows ...'
+      end
+      # verify the required parameter 'x_timezone' is set
+      if @api_client.config.client_side_validation && x_timezone.nil?
+        fail ArgumentError, "Missing the required parameter 'x_timezone' when calling JobRequestBusinessApi.list_job_request_booking_windows"
+      end
+      # resource path
+      local_var_path = '/job-requests/booking-windows'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'from'] = opts[:'from'] if !opts[:'from'].nil?
+      query_params[:'to'] = opts[:'to'] if !opts[:'to'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      header_params[:'X-Timezone'] = x_timezone
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListJobRequestBookingWindows200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_job_request_booking_windows",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_job_request_booking_windows\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Poll for new & changed job requests (sync feed)
+    # Keep an external system (your CRM, ERP or field-operations tool) in sync with bookings WITHOUT re-listing everything: returns the job requests (work orders) whose state changed (created, status transition, reschedule, soft-delete/archive) at or after the `since` cursor, ordered oldest-change-first (updated_at ASC).  How to use it: (1) On your first poll OMIT `since` — the server primes the cursor at \"now\", returns no items and a `next_since`. (2) Store `next_since` and pass it as `since` on the next poll. (3) Apply each returned item to your store by UPSERTING on `id` (the server re-scans a ~5s safety window, so the same job may appear again — never blindly append). (4) If `has_more` is true the page filled to `limit` and more changes are already waiting — poll again immediately; otherwise wait your normal interval (e.g. 5–15s).  This is NOT pagination — it is a time-keyed change feed. Use the paginated GET /job-requests for the initial bulk load, then this endpoint to stay live. Filters (status_keys, customer_id, …) narrow the feed to the slice you care about.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :status_keys Comma-separated status slugs — only surface changes to jobs in these statuses
+    # @option opts [String] :priority Priority filter (p0|p1|p2|p3)
+    # @option opts [String] :customer_id Only changes to this customer&#39;s jobs (UUID)
+    # @option opts [String] :technician_id Only changes to jobs assigned to this technician (UUID)
+    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD &#x3D; start of that day in the business timezone, or RFC3339); range is [from, to)
+    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD &#x3D; end of that day in the business timezone, or RFC3339), exclusive
+    # @option opts [String] :since RFC3339 cursor from the prior response&#39;s next_since. OMIT on the first poll to prime the cursor at server-now.
+    # @option opts [Integer] :limit Max changes per poll (default 15, max 1000). If the page fills, has_more&#x3D;true.
+    # @return [ListJobRequestChanges200Response]
+    def list_job_request_changes(opts = {})
+      data, _status_code, _headers = list_job_request_changes_with_http_info(opts)
+      data
+    end
+
+    # Poll for new &amp; changed job requests (sync feed)
+    # Keep an external system (your CRM, ERP or field-operations tool) in sync with bookings WITHOUT re-listing everything: returns the job requests (work orders) whose state changed (created, status transition, reschedule, soft-delete/archive) at or after the &#x60;since&#x60; cursor, ordered oldest-change-first (updated_at ASC).  How to use it: (1) On your first poll OMIT &#x60;since&#x60; — the server primes the cursor at \&quot;now\&quot;, returns no items and a &#x60;next_since&#x60;. (2) Store &#x60;next_since&#x60; and pass it as &#x60;since&#x60; on the next poll. (3) Apply each returned item to your store by UPSERTING on &#x60;id&#x60; (the server re-scans a ~5s safety window, so the same job may appear again — never blindly append). (4) If &#x60;has_more&#x60; is true the page filled to &#x60;limit&#x60; and more changes are already waiting — poll again immediately; otherwise wait your normal interval (e.g. 5–15s).  This is NOT pagination — it is a time-keyed change feed. Use the paginated GET /job-requests for the initial bulk load, then this endpoint to stay live. Filters (status_keys, customer_id, …) narrow the feed to the slice you care about.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :status_keys Comma-separated status slugs — only surface changes to jobs in these statuses
+    # @option opts [String] :priority Priority filter (p0|p1|p2|p3)
+    # @option opts [String] :customer_id Only changes to this customer&#39;s jobs (UUID)
+    # @option opts [String] :technician_id Only changes to jobs assigned to this technician (UUID)
+    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD &#x3D; start of that day in the business timezone, or RFC3339); range is [from, to)
+    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD &#x3D; end of that day in the business timezone, or RFC3339), exclusive
+    # @option opts [String] :since RFC3339 cursor from the prior response&#39;s next_since. OMIT on the first poll to prime the cursor at server-now.
+    # @option opts [Integer] :limit Max changes per poll (default 15, max 1000). If the page fills, has_more&#x3D;true.
+    # @return [Array<(ListJobRequestChanges200Response, Integer, Hash)>] ListJobRequestChanges200Response data, response status code and response headers
+    def list_job_request_changes_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_job_request_changes ...'
+      end
+      # resource path
+      local_var_path = '/job-requests/changes'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'status_keys'] = opts[:'status_keys'] if !opts[:'status_keys'].nil?
+      query_params[:'priority'] = opts[:'priority'] if !opts[:'priority'].nil?
+      query_params[:'customer_id'] = opts[:'customer_id'] if !opts[:'customer_id'].nil?
+      query_params[:'technician_id'] = opts[:'technician_id'] if !opts[:'technician_id'].nil?
+      query_params[:'scheduled_from'] = opts[:'scheduled_from'] if !opts[:'scheduled_from'].nil?
+      query_params[:'scheduled_to'] = opts[:'scheduled_to'] if !opts[:'scheduled_to'].nil?
+      query_params[:'since'] = opts[:'since'] if !opts[:'since'].nil?
+      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListJobRequestChanges200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_job_request_changes",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_job_request_changes\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # List job requests
+    # Paginated list of the business's bookings (work orders) with dispatch-oriented filters: workflow status, customer, assigned technician, scheduled date range and free-text search over code/description. This is also the SCHEDULE query: combine technician_id + scheduled_from/scheduled_to to read one technician's agenda for a day or week (e.g. \"what is Alex doing tomorrow\"), or just the date range for the whole team's calendar.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :status_keys Comma-separated status slugs
+    # @option opts [String] :status active (default) | archived | all
+    # @option opts [String] :priority Priority filter (p0|p1|p2|p3)
+    # @option opts [String] :customer_id Customer UUID
+    # @option opts [String] :technician_id Technician UUID
+    # @option opts [String] :service_area_id Service-area UUID (board zone filter)
+    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD &#x3D; start of that day in the business timezone, or RFC3339); range is [from, to)
+    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD &#x3D; end of that day in the business timezone, or RFC3339), exclusive
+    # @option opts [String] :completed_from Filter by completion time from (YYYY-MM-DD &#x3D; start of that day in the business timezone, or RFC3339); range is [from, to). Counts jobs by when they were completed regardless of reschedules.
+    # @option opts [String] :completed_to Filter by completion time to (YYYY-MM-DD &#x3D; end of that day in the business timezone, or RFC3339), exclusive
+    # @option opts [String] :q Search short_code or description (case-insensitive, partial match)
+    # @option opts [String] :sort Sort key: created_at:desc (default) | created_at:asc | scheduled_at:asc | scheduled_at:desc | priority:asc (P0 first) | priority:desc
+    # @option opts [Integer] :page Page number
+    # @option opts [Integer] :limit Page size
+    # @return [ListJobRequests200Response]
+    def list_job_requests(opts = {})
+      data, _status_code, _headers = list_job_requests_with_http_info(opts)
+      data
+    end
+
+    # List job requests
+    # Paginated list of the business&#39;s bookings (work orders) with dispatch-oriented filters: workflow status, customer, assigned technician, scheduled date range and free-text search over code/description. This is also the SCHEDULE query: combine technician_id + scheduled_from/scheduled_to to read one technician&#39;s agenda for a day or week (e.g. \&quot;what is Alex doing tomorrow\&quot;), or just the date range for the whole team&#39;s calendar.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :status_keys Comma-separated status slugs
+    # @option opts [String] :status active (default) | archived | all
+    # @option opts [String] :priority Priority filter (p0|p1|p2|p3)
+    # @option opts [String] :customer_id Customer UUID
+    # @option opts [String] :technician_id Technician UUID
+    # @option opts [String] :service_area_id Service-area UUID (board zone filter)
+    # @option opts [String] :scheduled_from Filter from (YYYY-MM-DD &#x3D; start of that day in the business timezone, or RFC3339); range is [from, to)
+    # @option opts [String] :scheduled_to Filter to (YYYY-MM-DD &#x3D; end of that day in the business timezone, or RFC3339), exclusive
+    # @option opts [String] :completed_from Filter by completion time from (YYYY-MM-DD &#x3D; start of that day in the business timezone, or RFC3339); range is [from, to). Counts jobs by when they were completed regardless of reschedules.
+    # @option opts [String] :completed_to Filter by completion time to (YYYY-MM-DD &#x3D; end of that day in the business timezone, or RFC3339), exclusive
+    # @option opts [String] :q Search short_code or description (case-insensitive, partial match)
+    # @option opts [String] :sort Sort key: created_at:desc (default) | created_at:asc | scheduled_at:asc | scheduled_at:desc | priority:asc (P0 first) | priority:desc
+    # @option opts [Integer] :page Page number
+    # @option opts [Integer] :limit Page size
+    # @return [Array<(ListJobRequests200Response, Integer, Hash)>] ListJobRequests200Response data, response status code and response headers
+    def list_job_requests_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_job_requests ...'
+      end
+      # resource path
+      local_var_path = '/job-requests'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'status_keys'] = opts[:'status_keys'] if !opts[:'status_keys'].nil?
+      query_params[:'status'] = opts[:'status'] if !opts[:'status'].nil?
+      query_params[:'priority'] = opts[:'priority'] if !opts[:'priority'].nil?
+      query_params[:'customer_id'] = opts[:'customer_id'] if !opts[:'customer_id'].nil?
+      query_params[:'technician_id'] = opts[:'technician_id'] if !opts[:'technician_id'].nil?
+      query_params[:'service_area_id'] = opts[:'service_area_id'] if !opts[:'service_area_id'].nil?
+      query_params[:'scheduled_from'] = opts[:'scheduled_from'] if !opts[:'scheduled_from'].nil?
+      query_params[:'scheduled_to'] = opts[:'scheduled_to'] if !opts[:'scheduled_to'].nil?
+      query_params[:'completed_from'] = opts[:'completed_from'] if !opts[:'completed_from'].nil?
+      query_params[:'completed_to'] = opts[:'completed_to'] if !opts[:'completed_to'].nil?
+      query_params[:'q'] = opts[:'q'] if !opts[:'q'].nil?
+      query_params[:'sort'] = opts[:'sort'] if !opts[:'sort'].nil?
+      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
+      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListJobRequests200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_job_requests",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_job_requests\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Matching time slots for a quoted job
+    # Bookable arrival-window slots for a quoted job, computed by the smart-assignment matching engine: each slot lists the technicians actually available to start then (skills, weekly availability, existing schedule, time off and travel all checked), with a per-technician match score. Use it to find and offer appointment times an agent or integration can then confirm (POST /job-requests/{id}/confirm with the slot's business_time.datetime). Same grid the end-customer's slot picker shows; slot width defaults to the business's arrival window — override via ?step_minutes (5–240). The job must be quoted first (the quote sets the visit duration the matcher schedules).
+    # @param id [String] Job request ID (UUID or short_code)
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :step_minutes Slot step in minutes (default: business arrival window, 5–240)
+    # @return [ListMatchingSlots200Response]
+    def list_matching_slots(id, opts = {})
+      data, _status_code, _headers = list_matching_slots_with_http_info(id, opts)
+      data
+    end
+
+    # Matching time slots for a quoted job
+    # Bookable arrival-window slots for a quoted job, computed by the smart-assignment matching engine: each slot lists the technicians actually available to start then (skills, weekly availability, existing schedule, time off and travel all checked), with a per-technician match score. Use it to find and offer appointment times an agent or integration can then confirm (POST /job-requests/{id}/confirm with the slot&#39;s business_time.datetime). Same grid the end-customer&#39;s slot picker shows; slot width defaults to the business&#39;s arrival window — override via ?step_minutes (5–240). The job must be quoted first (the quote sets the visit duration the matcher schedules).
+    # @param id [String] Job request ID (UUID or short_code)
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :step_minutes Slot step in minutes (default: business arrival window, 5–240)
+    # @return [Array<(ListMatchingSlots200Response, Integer, Hash)>] ListMatchingSlots200Response data, response status code and response headers
+    def list_matching_slots_with_http_info(id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_matching_slots ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.list_matching_slots"
+      end
+      # resource path
+      local_var_path = '/job-requests/{id}/time-segments'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'step_minutes'] = opts[:'step_minutes'] if !opts[:'step_minutes'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListMatchingSlots200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_matching_slots",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_matching_slots\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Find nearby feasible technicians (job-less location query)
+    # Ranks who could serve a hypothetical visit at (lat,lng) starting `at` for `duration_minutes` — the engine applies the REAL hard filters (weekly hours, existing schedule, approved time-off, geographic service areas, optional skill floor) and returns candidates nearest-arrival first. ETA origin is each technician's start location (no live GPS). Use before creating a booking to propose realistic arrivals.
+    # @param lat [Float] Latitude of the service location
+    # @param lng [Float] Longitude of the service location
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :at Visit start (RFC3339, e.g. 2026-07-20T14:00:00Z; default now)
+    # @option opts [Integer] :duration_minutes Visit length in minutes (default 60; 15–480)
+    # @option opts [String] :skill_ids Comma-separated skill UUIDs to require/match
+    # @option opts [Integer] :limit Max candidates (default 10, max 20)
+    # @return [ListNearbyTechnicians200Response]
+    def list_nearby_technicians(lat, lng, opts = {})
+      data, _status_code, _headers = list_nearby_technicians_with_http_info(lat, lng, opts)
+      data
+    end
+
+    # Find nearby feasible technicians (job-less location query)
+    # Ranks who could serve a hypothetical visit at (lat,lng) starting &#x60;at&#x60; for &#x60;duration_minutes&#x60; — the engine applies the REAL hard filters (weekly hours, existing schedule, approved time-off, geographic service areas, optional skill floor) and returns candidates nearest-arrival first. ETA origin is each technician&#39;s start location (no live GPS). Use before creating a booking to propose realistic arrivals.
+    # @param lat [Float] Latitude of the service location
+    # @param lng [Float] Longitude of the service location
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :at Visit start (RFC3339, e.g. 2026-07-20T14:00:00Z; default now)
+    # @option opts [Integer] :duration_minutes Visit length in minutes (default 60; 15–480)
+    # @option opts [String] :skill_ids Comma-separated skill UUIDs to require/match
+    # @option opts [Integer] :limit Max candidates (default 10, max 20)
+    # @return [Array<(ListNearbyTechnicians200Response, Integer, Hash)>] ListNearbyTechnicians200Response data, response status code and response headers
+    def list_nearby_technicians_with_http_info(lat, lng, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.list_nearby_technicians ...'
+      end
+      # verify the required parameter 'lat' is set
+      if @api_client.config.client_side_validation && lat.nil?
+        fail ArgumentError, "Missing the required parameter 'lat' when calling JobRequestBusinessApi.list_nearby_technicians"
+      end
+      # verify the required parameter 'lng' is set
+      if @api_client.config.client_side_validation && lng.nil?
+        fail ArgumentError, "Missing the required parameter 'lng' when calling JobRequestBusinessApi.list_nearby_technicians"
+      end
+      # resource path
+      local_var_path = '/technicians/nearby'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'lat'] = lat
+      query_params[:'lng'] = lng
+      query_params[:'at'] = opts[:'at'] if !opts[:'at'].nil?
+      query_params[:'duration_minutes'] = opts[:'duration_minutes'] if !opts[:'duration_minutes'].nil?
+      query_params[:'skill_ids'] = opts[:'skill_ids'] if !opts[:'skill_ids'].nil?
+      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ListNearbyTechnicians200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.list_nearby_technicians",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#list_nearby_technicians\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Preview re-staffing a technician's whole day (sick call)
+    # Solves (WITHOUT writing) the re-staffing of every job on a technician's board for a date range: each job is handed to an ALTERNATE lead technician at its UNCHANGED window — the customer's appointment never moves, two overlapping jobs never land on the same alternate, and the absent technician is never a candidate. `date`/`until_date` are business-local calendar days (inclusive, ≤ 14 days). Jobs the planner cannot re-staff come back in `unresolved` with a `reason_code` (no qualified technician free / crew job / multi-day job / already in progress) — a partial plan is a normal 200, not an error. `solver.duration_ms` is server-side planner time; `solver.deterministic` is true (same input ⇒ same plan). Read-only, safe to repeat; copy `resolved[]` into the commit body. No time-off record is required to preview. When the strict pass leaves a job unresolved, its row ALSO carries `alternatives[]` — the relaxation ladder's priced options, cheapest constraint first (ABSENCE_RESOLVE_DESIGN.md §9): `reassign_out_of_area` (same window, a lead outside the job's zone — cost.distance_km/travel_minutes), then `reschedule_same_day` / `reschedule_later_day` (the earliest free window on a qualified lead, in-area before out-of-area, up to 3 working days past until_date — cost.customer_renotified, cost.day_offset, cost.sla_breached). Each option is a PROPOSAL: nothing is applied until the coordinator copies it into the commit body with its `alternative_kind` (+ `start_at`/`end_at` for a reschedule). `alternatives` is an empty array when even the ladder found nothing; `solver.alternatives_truncated` is true when the ladder's time budget cut the search short. Displacing another customer's job and overtime are deliberately NOT offered. See ABSENCE_RESOLVE_DESIGN.md.
+    # @param job_request_absence_preview_request [JobRequestAbsencePreviewRequest] absent technician + date range (+ optional job subset)
+    # @param [Hash] opts the optional parameters
+    # @return [CommitAbsenceResolve200Response]
+    def preview_absence_resolve(job_request_absence_preview_request, opts = {})
+      data, _status_code, _headers = preview_absence_resolve_with_http_info(job_request_absence_preview_request, opts)
+      data
+    end
+
+    # Preview re-staffing a technician&#39;s whole day (sick call)
+    # Solves (WITHOUT writing) the re-staffing of every job on a technician&#39;s board for a date range: each job is handed to an ALTERNATE lead technician at its UNCHANGED window — the customer&#39;s appointment never moves, two overlapping jobs never land on the same alternate, and the absent technician is never a candidate. &#x60;date&#x60;/&#x60;until_date&#x60; are business-local calendar days (inclusive, ≤ 14 days). Jobs the planner cannot re-staff come back in &#x60;unresolved&#x60; with a &#x60;reason_code&#x60; (no qualified technician free / crew job / multi-day job / already in progress) — a partial plan is a normal 200, not an error. &#x60;solver.duration_ms&#x60; is server-side planner time; &#x60;solver.deterministic&#x60; is true (same input ⇒ same plan). Read-only, safe to repeat; copy &#x60;resolved[]&#x60; into the commit body. No time-off record is required to preview. When the strict pass leaves a job unresolved, its row ALSO carries &#x60;alternatives[]&#x60; — the relaxation ladder&#39;s priced options, cheapest constraint first (ABSENCE_RESOLVE_DESIGN.md §9): &#x60;reassign_out_of_area&#x60; (same window, a lead outside the job&#39;s zone — cost.distance_km/travel_minutes), then &#x60;reschedule_same_day&#x60; / &#x60;reschedule_later_day&#x60; (the earliest free window on a qualified lead, in-area before out-of-area, up to 3 working days past until_date — cost.customer_renotified, cost.day_offset, cost.sla_breached). Each option is a PROPOSAL: nothing is applied until the coordinator copies it into the commit body with its &#x60;alternative_kind&#x60; (+ &#x60;start_at&#x60;/&#x60;end_at&#x60; for a reschedule). &#x60;alternatives&#x60; is an empty array when even the ladder found nothing; &#x60;solver.alternatives_truncated&#x60; is true when the ladder&#39;s time budget cut the search short. Displacing another customer&#39;s job and overtime are deliberately NOT offered. See ABSENCE_RESOLVE_DESIGN.md.
+    # @param job_request_absence_preview_request [JobRequestAbsencePreviewRequest] absent technician + date range (+ optional job subset)
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CommitAbsenceResolve200Response, Integer, Hash)>] CommitAbsenceResolve200Response data, response status code and response headers
+    def preview_absence_resolve_with_http_info(job_request_absence_preview_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.preview_absence_resolve ...'
+      end
+      # verify the required parameter 'job_request_absence_preview_request' is set
+      if @api_client.config.client_side_validation && job_request_absence_preview_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_absence_preview_request' when calling JobRequestBusinessApi.preview_absence_resolve"
+      end
+      # resource path
+      local_var_path = '/job-requests/absence/preview'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_absence_preview_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CommitAbsenceResolve200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.preview_absence_resolve",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#preview_absence_resolve\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Preview emergency insert + cascade reschedule
+    # Computes (WITHOUT writing) the cascade of inserting an emergency job onto a technician at a chosen time: where the emergency lands + every job pushed back, grouped per business-local day. `displacement_mode=reassign` instead hands each displaced job to another feasible technician at its ORIGINAL window (same-day promise) — jobs with no alternate capacity fall back to reschedule and stay in `days`. `mode=overtime` keeps everyone same-day (tech works late); `mode=next_day` rolls overflow to the next working day(s). On a day the business does not work the preview does NOT need `after_hours_override`: it plans as the override would and returns `after_hours_override_required: true` plus an AFTER_HOURS warning — ask the coordinator whether they have phoned the technician, then commit with after_hours_override=true (the commit refuses without it). This endpoint never runs the technician's working-hours/time-off feasibility check (that only happens on /candidates) — it validates the named technician exists and builds the cascade. Read-only — safe to call repeatedly; commit is a separate endpoint. Isolated feature (see EMERGENCY_RESCHEDULE_DESIGN.md). 409 NEXT STEPS: EMERGENCY_RESCHEDULE_SLOT_OCCUPIED — the landing window is blocked by a job the cascade may NOT move (another P0, a crew or multi-day job); `data.conflicts[]` names each blocking job (short_code/start_at/end_at/frozen_because): choose another technician (walk the /candidates ranking) or another time; displacement never touches P0/crew/multi-day anchors. EMERGENCY_RESCHEDULE_NOT_ELIGIBLE / CREW_UNSUPPORTED / MULTIDAY_UNSUPPORTED / IN_PAST — same remedies and `data` shapes as /candidates. EMERGENCY_RESCHEDULE_NO_WORKING_DAY is never returned by the preview: since 2026-10-03 a closed day answers 200 with after_hours_override_required=true instead.
+    # @param job_request_emergency_preview_request [JobRequestEmergencyPreviewRequest] emergency insert spec
+    # @param [Hash] opts the optional parameters
+    # @return [CommitEmergencyReschedule200Response]
+    def preview_emergency_reschedule(job_request_emergency_preview_request, opts = {})
+      data, _status_code, _headers = preview_emergency_reschedule_with_http_info(job_request_emergency_preview_request, opts)
+      data
+    end
+
+    # Preview emergency insert + cascade reschedule
+    # Computes (WITHOUT writing) the cascade of inserting an emergency job onto a technician at a chosen time: where the emergency lands + every job pushed back, grouped per business-local day. &#x60;displacement_mode&#x3D;reassign&#x60; instead hands each displaced job to another feasible technician at its ORIGINAL window (same-day promise) — jobs with no alternate capacity fall back to reschedule and stay in &#x60;days&#x60;. &#x60;mode&#x3D;overtime&#x60; keeps everyone same-day (tech works late); &#x60;mode&#x3D;next_day&#x60; rolls overflow to the next working day(s). On a day the business does not work the preview does NOT need &#x60;after_hours_override&#x60;: it plans as the override would and returns &#x60;after_hours_override_required: true&#x60; plus an AFTER_HOURS warning — ask the coordinator whether they have phoned the technician, then commit with after_hours_override&#x3D;true (the commit refuses without it). This endpoint never runs the technician&#39;s working-hours/time-off feasibility check (that only happens on /candidates) — it validates the named technician exists and builds the cascade. Read-only — safe to call repeatedly; commit is a separate endpoint. Isolated feature (see EMERGENCY_RESCHEDULE_DESIGN.md). 409 NEXT STEPS: EMERGENCY_RESCHEDULE_SLOT_OCCUPIED — the landing window is blocked by a job the cascade may NOT move (another P0, a crew or multi-day job); &#x60;data.conflicts[]&#x60; names each blocking job (short_code/start_at/end_at/frozen_because): choose another technician (walk the /candidates ranking) or another time; displacement never touches P0/crew/multi-day anchors. EMERGENCY_RESCHEDULE_NOT_ELIGIBLE / CREW_UNSUPPORTED / MULTIDAY_UNSUPPORTED / IN_PAST — same remedies and &#x60;data&#x60; shapes as /candidates. EMERGENCY_RESCHEDULE_NO_WORKING_DAY is never returned by the preview: since 2026-10-03 a closed day answers 200 with after_hours_override_required&#x3D;true instead.
+    # @param job_request_emergency_preview_request [JobRequestEmergencyPreviewRequest] emergency insert spec
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CommitEmergencyReschedule200Response, Integer, Hash)>] CommitEmergencyReschedule200Response data, response status code and response headers
+    def preview_emergency_reschedule_with_http_info(job_request_emergency_preview_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.preview_emergency_reschedule ...'
+      end
+      # verify the required parameter 'job_request_emergency_preview_request' is set
+      if @api_client.config.client_side_validation && job_request_emergency_preview_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_emergency_preview_request' when calling JobRequestBusinessApi.preview_emergency_reschedule"
+      end
+      # resource path
+      local_var_path = '/job-requests/emergency/preview'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_emergency_preview_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CommitEmergencyReschedule200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.preview_emergency_reschedule",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#preview_emergency_reschedule\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Preview a schedule-board job move
+    # Computes (WITHOUT writing) the outcome of moving a confirmed job to a new time and/or technician: where it lands, every later job pushed back per `mode`, and the warnings the coordinator would accept (displaced jobs leaving their confirmed windows, overtime). Same technician = pure time move; different technician = manual reassign. Read-only — safe to call repeatedly while dragging; commit is a separate endpoint. On a day the business does not work, a p0 single-person job previews WITHOUT after_hours_override: the plan is computed as the override would place it and the response carries `after_hours_override_required: true` — ask the coordinator whether they have phoned the technician, then commit with after_hours_override=true. Any other job is refused with SCHEDULE_MOVE_NO_WORKING_DAY and `data.override_available: false`. See SCHEDULE_BOARD_DESIGN.md. Warning detail: a TECH_NOT_FEASIBLE warning carries `reason` (= `blockers[0].kind`) = `outside_service_area` | `missing_required_skills` | `not_lead_tier` | `no_working_day` | `on_time_off` | `off_shift` | `visit_too_long` | `cannot_arrive_in_time` (commute from the tech day-start location / shift start; `earliest_feasible_at`, RFC3339 UTC, is the first same-day time they CAN be on site — suggest it as the drop slot) | `not_available_today` (diagnosis unavailable). `blockers[]` names EVERY hard filter that failed, most-structural first — a client reading only `reason` still works. For a P0 move this warning is advisory (coordinator may commit anyway) and carries the SAME `blockers[]` a p1/p2/p3 move would get as the hard 409 SCHEDULE_MOVE_TECH_INFEASIBLE below. 409 NEXT STEPS: SCHEDULE_MOVE_NOT_ELIGIBLE (job unconfirmed/unquoted/archived/completed — `data.failed_precondition` names which) · SCHEDULE_MOVE_IN_PROGRESS (tech already executing — `data.fired_actions[]` lists the actions already fired; do not move) · SCHEDULE_MOVE_IN_PAST (pick a future time — its `data` carries `business_timezone`, the naive `start_at` and the `start_at_utc` it resolved to, which is what tells a caller whose own clock says otherwise where the difference came from) · SCHEDULE_MOVE_SLOT_OCCUPIED (landing window blocked by an immovable anchor; `data.conflicts[]` names it — another tech/time) · SCHEDULE_MOVE_TECH_INFEASIBLE (non-P0 hard block: target tech not qualified/available — its `data` carries `technician` (id+name), `reason` (same catalog as the TECH_NOT_FEASIBLE warning above), `blockers[]` (every cause, most-structural first) and, for `cannot_arrive_in_time`, `earliest_feasible_at` (RFC3339 UTC) to suggest as the drop slot; change tech or time) · SCHEDULE_MOVE_MULTIDAY_UNSUPPORTED (multi-day jobs not movable v1 — `data.session_count`/`data.session_dates`) · SCHEDULE_MOVE_NO_WORKING_DAY (`data.business_timezone`/`data.requested_weekday` — pick a working day, or set after_hours_override=true for a P0 whose technician has been phoned) · SCHEDULE_MOVE_REQUIRES_FREE_SLOT (non-P0 moves may not displace — `data.would_push[]` names the jobs that would be pushed, `data.allow_non_p0_displacement: false` names the setting that would permit it, unless the crew case sets `data.crew_never_displaces: true` instead — free capacity only) · SCHEDULE_MOVE_CREW_UNSTAFFABLE (a crew slot has no feasible replacement at the new time — another time). A landing outside the customer-confirmed window is NOT an error — it returns 200 with a MOVED_OUTSIDE_WINDOW warning (customer_window attached) that the coordinator overrides.
+    # @param id [String] Job request ID (UUID or short_code)
+    # @param job_request_move_preview_req [JobRequestMovePreviewReq] move spec
+    # @param [Hash] opts the optional parameters
+    # @return [CommitJobRequestMove200Response]
+    def preview_job_request_move(id, job_request_move_preview_req, opts = {})
+      data, _status_code, _headers = preview_job_request_move_with_http_info(id, job_request_move_preview_req, opts)
+      data
+    end
+
+    # Preview a schedule-board job move
+    # Computes (WITHOUT writing) the outcome of moving a confirmed job to a new time and/or technician: where it lands, every later job pushed back per &#x60;mode&#x60;, and the warnings the coordinator would accept (displaced jobs leaving their confirmed windows, overtime). Same technician &#x3D; pure time move; different technician &#x3D; manual reassign. Read-only — safe to call repeatedly while dragging; commit is a separate endpoint. On a day the business does not work, a p0 single-person job previews WITHOUT after_hours_override: the plan is computed as the override would place it and the response carries &#x60;after_hours_override_required: true&#x60; — ask the coordinator whether they have phoned the technician, then commit with after_hours_override&#x3D;true. Any other job is refused with SCHEDULE_MOVE_NO_WORKING_DAY and &#x60;data.override_available: false&#x60;. See SCHEDULE_BOARD_DESIGN.md. Warning detail: a TECH_NOT_FEASIBLE warning carries &#x60;reason&#x60; (&#x3D; &#x60;blockers[0].kind&#x60;) &#x3D; &#x60;outside_service_area&#x60; | &#x60;missing_required_skills&#x60; | &#x60;not_lead_tier&#x60; | &#x60;no_working_day&#x60; | &#x60;on_time_off&#x60; | &#x60;off_shift&#x60; | &#x60;visit_too_long&#x60; | &#x60;cannot_arrive_in_time&#x60; (commute from the tech day-start location / shift start; &#x60;earliest_feasible_at&#x60;, RFC3339 UTC, is the first same-day time they CAN be on site — suggest it as the drop slot) | &#x60;not_available_today&#x60; (diagnosis unavailable). &#x60;blockers[]&#x60; names EVERY hard filter that failed, most-structural first — a client reading only &#x60;reason&#x60; still works. For a P0 move this warning is advisory (coordinator may commit anyway) and carries the SAME &#x60;blockers[]&#x60; a p1/p2/p3 move would get as the hard 409 SCHEDULE_MOVE_TECH_INFEASIBLE below. 409 NEXT STEPS: SCHEDULE_MOVE_NOT_ELIGIBLE (job unconfirmed/unquoted/archived/completed — &#x60;data.failed_precondition&#x60; names which) · SCHEDULE_MOVE_IN_PROGRESS (tech already executing — &#x60;data.fired_actions[]&#x60; lists the actions already fired; do not move) · SCHEDULE_MOVE_IN_PAST (pick a future time — its &#x60;data&#x60; carries &#x60;business_timezone&#x60;, the naive &#x60;start_at&#x60; and the &#x60;start_at_utc&#x60; it resolved to, which is what tells a caller whose own clock says otherwise where the difference came from) · SCHEDULE_MOVE_SLOT_OCCUPIED (landing window blocked by an immovable anchor; &#x60;data.conflicts[]&#x60; names it — another tech/time) · SCHEDULE_MOVE_TECH_INFEASIBLE (non-P0 hard block: target tech not qualified/available — its &#x60;data&#x60; carries &#x60;technician&#x60; (id+name), &#x60;reason&#x60; (same catalog as the TECH_NOT_FEASIBLE warning above), &#x60;blockers[]&#x60; (every cause, most-structural first) and, for &#x60;cannot_arrive_in_time&#x60;, &#x60;earliest_feasible_at&#x60; (RFC3339 UTC) to suggest as the drop slot; change tech or time) · SCHEDULE_MOVE_MULTIDAY_UNSUPPORTED (multi-day jobs not movable v1 — &#x60;data.session_count&#x60;/&#x60;data.session_dates&#x60;) · SCHEDULE_MOVE_NO_WORKING_DAY (&#x60;data.business_timezone&#x60;/&#x60;data.requested_weekday&#x60; — pick a working day, or set after_hours_override&#x3D;true for a P0 whose technician has been phoned) · SCHEDULE_MOVE_REQUIRES_FREE_SLOT (non-P0 moves may not displace — &#x60;data.would_push[]&#x60; names the jobs that would be pushed, &#x60;data.allow_non_p0_displacement: false&#x60; names the setting that would permit it, unless the crew case sets &#x60;data.crew_never_displaces: true&#x60; instead — free capacity only) · SCHEDULE_MOVE_CREW_UNSTAFFABLE (a crew slot has no feasible replacement at the new time — another time). A landing outside the customer-confirmed window is NOT an error — it returns 200 with a MOVED_OUTSIDE_WINDOW warning (customer_window attached) that the coordinator overrides.
+    # @param id [String] Job request ID (UUID or short_code)
+    # @param job_request_move_preview_req [JobRequestMovePreviewReq] move spec
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CommitJobRequestMove200Response, Integer, Hash)>] CommitJobRequestMove200Response data, response status code and response headers
+    def preview_job_request_move_with_http_info(id, job_request_move_preview_req, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.preview_job_request_move ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.preview_job_request_move"
+      end
+      # verify the required parameter 'job_request_move_preview_req' is set
+      if @api_client.config.client_side_validation && job_request_move_preview_req.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_move_preview_req' when calling JobRequestBusinessApi.preview_job_request_move"
+      end
+      # resource path
+      local_var_path = '/job-requests/{id}/move/preview'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_move_preview_req)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'CommitJobRequestMove200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.preview_job_request_move",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#preview_job_request_move\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Fire quote (FIXED action — business)
+    # Sends the quote: sets quoted_at + duration cols, advances pending_action to confirm_booking. Status stays `booking`. job_duration_minutes may be omitted when the job's job type has a default_duration_minutes: the type's default duration and buffers are used (a buffer you send still wins). This is how an automation or voice agent schedules work it cannot size. Before writing, checks that the customer will see at least one slot: the same engine as the customer slot picker runs over the windows the customer asked for with THIS quote's duration (working hours, service areas, time-off, existing bookings, crew coverage). If no slot exists the quote is refused with 409 JOB_REQUEST_QUOTE_NOT_SCHEDULABLE; data.reason says why (outside_working_hours, requested_windows_passed, outside_service_area, off_shift, on_time_off, missing_required_skills, no_technician_available, ...) and data.blocked_by counts the roster per blocker. Send force=true to schedule it anyway after agreeing a time with the customer.
+    # @param id [String] Job request ID
+    # @param job_request_quote_request [JobRequestQuoteRequest] Quote payload
+    # @param [Hash] opts the optional parameters
+    # @return [QuoteJobRequest200Response]
+    def quote_job_request(id, job_request_quote_request, opts = {})
+      data, _status_code, _headers = quote_job_request_with_http_info(id, job_request_quote_request, opts)
+      data
+    end
+
+    # Fire quote (FIXED action — business)
+    # Sends the quote: sets quoted_at + duration cols, advances pending_action to confirm_booking. Status stays &#x60;booking&#x60;. job_duration_minutes may be omitted when the job&#39;s job type has a default_duration_minutes: the type&#39;s default duration and buffers are used (a buffer you send still wins). This is how an automation or voice agent schedules work it cannot size. Before writing, checks that the customer will see at least one slot: the same engine as the customer slot picker runs over the windows the customer asked for with THIS quote&#39;s duration (working hours, service areas, time-off, existing bookings, crew coverage). If no slot exists the quote is refused with 409 JOB_REQUEST_QUOTE_NOT_SCHEDULABLE; data.reason says why (outside_working_hours, requested_windows_passed, outside_service_area, off_shift, on_time_off, missing_required_skills, no_technician_available, ...) and data.blocked_by counts the roster per blocker. Send force&#x3D;true to schedule it anyway after agreeing a time with the customer.
+    # @param id [String] Job request ID
+    # @param job_request_quote_request [JobRequestQuoteRequest] Quote payload
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(QuoteJobRequest200Response, Integer, Hash)>] QuoteJobRequest200Response data, response status code and response headers
+    def quote_job_request_with_http_info(id, job_request_quote_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.quote_job_request ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.quote_job_request"
+      end
+      # verify the required parameter 'job_request_quote_request' is set
+      if @api_client.config.client_side_validation && job_request_quote_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_quote_request' when calling JobRequestBusinessApi.quote_job_request"
+      end
+      # resource path
+      local_var_path = '/job-requests/{id}/quote'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_quote_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'QuoteJobRequest200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.quote_job_request",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#quote_job_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Set job priority (scheduling staff)
+    # Sets the P0–P3 priority on a non-archived, non-completed job (Owner / Administrator / Booking Coordinator). Allowed values: \"p0\" (emergency, interrupt-driven) | \"p1\" (top — displaced only by p0; may carry an sla_deadline arming auto-escalation) | \"p2\" (standard) | \"p3\" (deferrable, first displacement victim). sla_deadline is only valid with p1 and must be in the future (business-local naive datetime); moving away from p1 disarms the SLA clock. Accepts UUID or short_code in :id. Lowering a job to anything but p0 never moves it: when it still sits outside the business's working hours (typically placed there earlier through the after-hours override) the response carries an AFTER_HOURS warning per affected session, and the job should be moved back to a working day.
+    # @param id [String] Job request ID or short_code
+    # @param job_request_update_priority_request [JobRequestUpdatePriorityRequest] Priority payload
+    # @param [Hash] opts the optional parameters
+    # @return [ResponseEnvelope]
+    def update_job_priority(id, job_request_update_priority_request, opts = {})
+      data, _status_code, _headers = update_job_priority_with_http_info(id, job_request_update_priority_request, opts)
+      data
+    end
+
+    # Set job priority (scheduling staff)
+    # Sets the P0–P3 priority on a non-archived, non-completed job (Owner / Administrator / Booking Coordinator). Allowed values: \&quot;p0\&quot; (emergency, interrupt-driven) | \&quot;p1\&quot; (top — displaced only by p0; may carry an sla_deadline arming auto-escalation) | \&quot;p2\&quot; (standard) | \&quot;p3\&quot; (deferrable, first displacement victim). sla_deadline is only valid with p1 and must be in the future (business-local naive datetime); moving away from p1 disarms the SLA clock. Accepts UUID or short_code in :id. Lowering a job to anything but p0 never moves it: when it still sits outside the business&#39;s working hours (typically placed there earlier through the after-hours override) the response carries an AFTER_HOURS warning per affected session, and the job should be moved back to a working day.
+    # @param id [String] Job request ID or short_code
+    # @param job_request_update_priority_request [JobRequestUpdatePriorityRequest] Priority payload
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(ResponseEnvelope, Integer, Hash)>] ResponseEnvelope data, response status code and response headers
+    def update_job_priority_with_http_info(id, job_request_update_priority_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: JobRequestBusinessApi.update_job_priority ...'
+      end
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling JobRequestBusinessApi.update_job_priority"
+      end
+      # verify the required parameter 'job_request_update_priority_request' is set
+      if @api_client.config.client_side_validation && job_request_update_priority_request.nil?
+        fail ArgumentError, "Missing the required parameter 'job_request_update_priority_request' when calling JobRequestBusinessApi.update_job_priority"
+      end
+      # resource path
+      local_var_path = '/job-requests/{id}/priority'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(job_request_update_priority_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ResponseEnvelope'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['ApiKeyAuth']
+
+      new_options = opts.merge(
+        :operation => :"JobRequestBusinessApi.update_job_priority",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: JobRequestBusinessApi#update_job_priority\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end