seatlayer 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe617b9eff9a2dbeb571b81e16f8d41096b4cb4d49f35a3461f03b292316a87
-  data.tar.gz: d901b82e10dd7194b726f7c3d4b8f2d642030a1458c42ae7a851b200a9b0ef9a
+  metadata.gz: 841def7560b63781babf931924a29204c724ba5b4513eff1de283a370cb22699
+  data.tar.gz: 7027c38a8aeeee9aa5c339d90d04b33c4d708e47362687951d30dc280402bef4
 SHA512:
-  metadata.gz: d12c27e2f846f0aca0f95e8cc064723f9ad5ff37a83c64a854529db34a4b4651865011e3634a4eacd48bed9214e8ee64e1bccf162db24ca21d020f035cd6f091
-  data.tar.gz: e764024fd33ae0ca89714490934a7bbac28a2527a0ccee40a1892b1d2292f6945deb575c28b69665f77fcb04dd2ba987b1ce80cdb0b512236a497386563ee9c3
+  metadata.gz: 2ef313b0db74c36aef5d0f512264586448d99330e1257c8a28b835da54a7b539fd3f9ab7183a91ae912cf1e55ec2c5dcede861260d80b77a4ed0eaaa6d1faaba
+  data.tar.gz: e85e01d772d6639a36d7fa7154a062d60564fbbe750258c1080fa4f7cc17eba25277ebc0e7e31ad0f04589b9d716402c486c6c325b3d202e7c7fd2ed9e96c903

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.7.0 — 2026-08-30
+
+- Added coverage for all 48 Fixed Renewable Season server
+  operations under `client.seasons`, with exact path encoding and
+  operation-specific retry/idempotency behavior.
+- Season allocations are identity-only and the API response declares host
+  pricing authority. Buyer rehearsal validation sends no evidence body because
+  SeatLayer discovers the retained hold, booking, cancellation, and delivered
+  webhook chain automatically.
+
 ## 0.6.1
 
 - Documentation only. Refreshes the README, adds frequently asked

data/README.md

@@ -5,21 +5,21 @@
 [![Ruby](https://img.shields.io/badge/Ruby-%E2%89%A53.0-CC342D.svg)](https://www.ruby-lang.org/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-111827.svg)](LICENSE)
 
-The official SeatLayer Ruby server SDK — the trusted side of a reserved-seating
-integration. Inspect what a hold really contains, price from server-owned seating-chart
-data, and book with a stable `booking_ref`, while managing charts, events, inventory,
-allocations, and webhooks through one typed ticketing API client.
+SeatLayer's official Ruby server SDK is the trusted side of its reserved seating and seat booking
+API. Inspect what a hold really contains, price from server-owned seating-chart data, and book
+with a stable `booking_ref`, while managing charts, events, inventory, allocations, and webhooks
+through one typed ticketing API client.
 
 [`seatlayer` gem on RubyGems](https://rubygems.org/gems/seatlayer) ·
-[SeatLayer server SDK documentation](https://docs.seatlayer.io/server-sdk/install/) ·
-[SeatLayer reserved-seating platform](https://seatlayer.io/) ·
+[Ruby server SDK guide](https://docs.seatlayer.io/server-sdk/ruby/) ·
+[SeatLayer developer platform](https://seatlayer.io/developers/) ·
 [SeatLayer JavaScript seat map SDK](https://www.npmjs.com/package/@seatlayer/js) ·
-[Server API reference](https://docs.seatlayer.io/server-api/)
+[Server API reference](https://docs.seatlayer.io/server-api/events/)
 
 > **Server-side only.** This gem authenticates with your secret key. Never load it anywhere a
 > ticket buyer can reach — browser surfaces get short-lived, origin-bound tokens that you mint here.
 
-## Install
+## Install the Ruby seat booking SDK
 
 ```ruby
 gem "seatlayer"
@@ -40,11 +40,16 @@ require "seatlayer"
 client = SeatLayer::Client.new(ENV.fetch("SEATLAYER_SECRET_KEY"))
 
 # 1. Provision a venue for a new organiser from a public template.
-chart = client.templates.instantiate_template("arena-standard")["meta"]
+# Replace this placeholder with a template id from your catalog.
+chart = client.templates.instantiate_template("your-published-template")["meta"]
 client.charts.publish(chart["id"])
 
 # 2. Create an event on it.
-event = client.events.create(chart_id: chart["id"], name: "Spring Gala")["meta"]
+event = client.events.create(
+  chart_id: chart["id"], name: "Spring Gala",
+  currency: "EUR", # omit to inherit the workspace currency
+  region: "western-europe" # India: "asia-pacific"
+)["meta"]
 
 # 3. Sell four seats over the phone.
 held = client.inventory.hold_best_available(event["key"], qty: 4)
@@ -52,9 +57,50 @@ held = client.inventory.hold_best_available(event["key"], qty: 4)
 client.inventory.book(event["key"], hold_id: held["holdId"], booking_ref: "order-8842")
 ```
 
+## Event hosting region
+
+Pass `region:` to `events.create` based on the **event venue**, not your API server or office. It
+controls the initial placement of the Event's live inventory; an existing Event
+cannot be moved later. Omit it to inherit the workspace default (`western-europe` for new accounts).
+Set that default with `workspaces.create(default_region: ...)` or
+`workspaces.update(workspace_id, default_region: ...)`; changing it affects only future Events.
+
+- `western-europe`, `eastern-europe`, `north-america-east`, `north-america-west`, `south-america`
+- `asia-pacific`, `northeast-asia`, `southeast-asia`, `oceania`, `africa`, `middle-east`
+
+The hint is best effort, not a data-residency guarantee. See the
+[full Event region guide](https://docs.seatlayer.io/server-api/event-regions/).
+
 Nullable event-create fields distinguish omission from an explicit reset: passing, for example,
 `venue: nil` sends JSON `null`; leaving `venue` out sends no field.
 
+## Fixed Renewable Seasons
+
+Version `0.7.0` exposes all 48 trusted organizer operations through
+`client.seasons`.
+
+After the test hold/book/cancel journey and matching webhook deliveries,
+`validate_season_buyer_rehearsal(season_key)` sends no evidence body; SeatLayer
+discovers the retained chain automatically. Retrieved Season holds contain
+inventory identity, not an authoritative amount—your platform owns package
+price, payment, order, tax, refunds, benefits, and ticket or pass delivery.
+
+```ruby
+checked = client.seasons.validate_season(
+  source_performance_group_keys: ["pg_subscription_run"]
+)
+draft = client.seasons.create_season(
+  name: "2027 subscription",
+  source_performance_group_keys: ["pg_subscription_run"],
+  idempotency_key: "season-create-2027"
+).fetch("season")
+```
+
+Treat `202` as accepted work and poll `retrieve_season_lifecycle` with the
+returned operation identity. Buyer-session minting and domain-exact booking,
+cancellation, and renewal actions remain single-attempt; only declared
+header-replay catalogue mutations retry automatically.
+
 ## Test vs live
 
 Keys carry their own mode. `sk_test_…` keys can only touch test-mode events and `sk_live_…` only
@@ -69,15 +115,21 @@ raise "Refusing to boot production against test-mode seating data." if
 A publishable `pk_` key is rejected at construction with a message naming the mistake, rather than
 failing as a `401` three round-trips later.
 
-## The two selling flows
+## Book reserved seats from Ruby
 
 **Buyer picks seats in the browser.** Your frontend holds them; your backend confirms the price and
 books. Never price from what the browser sent you — `retrieve_hold` is authoritative.
 
 ```ruby
 hold = client.inventory.retrieve_hold(event_key, hold_id)
-total = hold["items"].sum { |item| item["unitPrice"] }
-# … charge `total` in hold["currency"] …
+currencies = hold["items"].map { |item| item.fetch("currency") }.uniq
+raise "A hold must use one currency" unless currencies.one?
+
+currency = currencies.first
+total = hold["items"].sum do |item|
+  item.fetch("unitPrice") * item.fetch("quantity", 1)
+end
+# … charge `total` in `currency` …
 client.inventory.book(event_key, hold_id: hold_id, booking_ref: charge.id)
 ```
 
@@ -177,12 +229,12 @@ The full set, all opt-in:
 |---|---|
 | `event:view` | Read the seat map and its live states |
 | `event:block` | Block and unblock seats |
-| `event:cancel` | Unbook paid seats and issue gateway refunds — destructive, moves money |
+| `event:cancel` | Cancel a Platform/SDK booking by reference and return its inventory to sale; does not move gateway money |
 | `event:reports` | Read sales and availability reports |
 | `event:channels:view` | Read sales channels and their allocations |
 | `event:channels:manage` | Create, pause and archive channels; rotate access links |
 | `event:orders:read` | Read SeatLayer-managed orders |
-| `event:refund` | Refund a SeatLayer-managed order |
+| `event:refund` | Refund an eligible Managed Ticketing order through its connected gateway |
 | `event:tickets:send` | Send SeatLayer-managed tickets |
 | `event:door:view` | Read the door list |
 | `event:door:checkin` | Check tickets in and out |
@@ -261,17 +313,20 @@ error carries `status`, `code`, `body` and `request_id` — quote the request id
 ## Reliability
 
 **Retries.** Reads (`GET`/`HEAD`) retry 429, 408 and 5xx with exponential backoff and full jitter;
-`Retry-After` wins when the server sends it. Automatic mutation retries are limited to the five
-operations backed by exact response replay: `charts.create`, `charts.copy`,
-`templates.instantiate_template`, `events.create`, and `workspaces.create`. Other 4xx responses
+`Retry-After` wins when the server sends it. Fourteen mutations use exact header replay:
+`charts.create`, `charts.copy`, `templates.instantiate_template`, `events.create`,
+`workspaces.create`, `performance_groups.create`, `seasons.create_season`,
+`seasons.update_season`, `seasons.delete_season`, `seasons.create_season_plan`,
+`seasons.duplicate_season_to_live`, `seasons.create_season_holder_import`,
+`seasons.create_season_renewal_offers`, and `seasons.create_season_amendment`. Other 4xx responses
 are never retried.
 
-**Idempotency.** Those five replay-backed operations carry an `Idempotency-Key`, generated when you
-do not supply one and reused across attempts. Other mutations are single-attempt and receive no
-automatic key. A caller-supplied key is forwarded but does not enable retries. This includes
-inventory holds and bookings, show-once credential or secret creation, unsupported operations, and
-raw `request` mutations. Keep `booking_ref` in the booking body for reconciliation, but handle an
-unknown network outcome explicitly instead of automatically repeating the sale.
+**Idempotency.** Those 14 replay-backed operations carry an `Idempotency-Key`, generated when you
+do not supply one and reused across attempts. All remaining SDK mutations are single-attempt. Some
+have a server-side domain idempotency contract, but the SDK does not retry them automatically. This
+includes inventory holds and bookings, show-once credential or secret creation, unsupported
+operations, and raw `request` mutations. Keep `booking_ref` in the booking body for reconciliation,
+but handle an unknown network outcome explicitly instead of automatically repeating the sale.
 
 ```ruby
 client.events.create(chart_id: chart_id, idempotency_key: "provision-event-#{event_id}")
@@ -296,6 +351,10 @@ client.request("POST", "/v1/events/ev_1/some-new-route", body: { "qty" => 2 })
 
 ## API surface
 
+The client exposes these resources. Performance Groups cover runs, sessions, holds, and bookings;
+Seasons cover catalogue, plan, sales, buyer-session, booking, renewal, occurrence, reporting,
+outbox, and support operations.
+
 | Resource | Methods |
 | --- | --- |
 | `charts` | `list` `list_all` `create` `retrieve` `update` `delete` `copy` `archive` `unarchive` `publish` |
@@ -306,8 +365,10 @@ client.request("POST", "/v1/events/ev_1/some-new-route", body: { "qty" => 2 })
 | `sessions` | `create_manage_session` `revoke_manage_session` `create_designer_session` `revoke_designer_session` |
 | `webhooks` | `list` `create` `update` `delete` `list_deliveries` |
 | `workspaces` | `list` `create` `retrieve` `update` |
+| `performance_groups` | `list` `create` `retrieve` `delete` `activate` `close` `retrieve_lifecycle` `create_buyer_access_session` `list_buyer_access_sessions` `revoke_buyer_access_session` `retrieve_hold` `book_hold` `retrieve_booking` |
+| `seasons` | 48 operations for catalogue and Plan lifecycle, sales windows, buyer access and booking, holder imports, renewals, occurrence amendments, reports, audit, outbox, and support export |
 
-Full reference: [docs.seatlayer.io/server-sdk](https://docs.seatlayer.io/server-sdk/install/)
+Full reference: [SeatLayer Ruby server SDK guide](https://docs.seatlayer.io/server-sdk/ruby/)
 
 ### Deliberately not in this SDK
 
@@ -358,16 +419,16 @@ outcome before trying again.
 
 ### Can I use my own payment provider?
 
-Yes. SeatLayer never processes payment. Inspect the hold, compute the charge from
-the returned `items` and their authoritative `unitPrice` and `currency`, take the
-money through whichever provider you already use — Stripe, Adyen, Razorpay, or your
-own — and then book the hold with your order id as `booking_ref`. SeatLayer owns
-seating state, holds, booking concurrency, and the inventory ledger; your platform
-owns payments, commercial orders, tickets, delivery, and refunds.
+Yes. This server SDK does not process payment in a Platform/SDK integration. Inspect the hold,
+compute the charge from each returned item's authoritative `unitPrice`, `quantity`, and `currency`,
+take the money through whichever provider you already use, and then book the hold with your order
+id as `booking_ref`. SeatLayer owns seating state, holds, booking concurrency, and the inventory
+ledger in this integration; your platform owns payments, commercial orders, tickets, delivery,
+and refunds. Managed Ticketing is a separate product path with organizer-connected payments.
 
 ## Continue your Ruby integration
 
-- [Follow the SeatLayer server SDK guide](https://docs.seatlayer.io/server-sdk/install/)
+- [Follow the Ruby server SDK guide](https://docs.seatlayer.io/server-sdk/ruby/)
   for installation, authentication, and the full hold-to-booking flow.
 - [Handle errors, retries, and safe booking repeats](https://docs.seatlayer.io/server-sdk/reliability/)
   before connecting a production order flow.

data/lib/seatlayer/http_client.rb

@@ -101,6 +101,12 @@ module SeatLayer
       request("POST", path, body: body, idempotency_key: idempotency_key, retry_policy: retry_policy)
     end
 
+    # Internal path for non-POST mutations backed by exact response replay.
+    def mutation_with_header_replay(method, path, body = nil, idempotency_key: nil)
+      request(method, path, body: body, idempotency_key: idempotency_key,
+                            retry_policy: :header_replay)
+    end
+
     def put(path, body)
       request("PUT", path, body: body)
     end

data/lib/seatlayer/inventory.rb

@@ -252,9 +252,14 @@ module SeatLayer
       @client.get("/v1/workspaces")
     end
 
-    def create(name:, external_ref: UNSET, idempotency_key: nil)
+    def create(name:, external_ref: UNSET, default_region: nil, idempotency_key: nil)
+      unless default_region.nil? || EVENT_HOSTING_REGIONS.include?(default_region)
+        raise ArgumentError, "default_region must be a supported SeatLayer Event region"
+      end
+
       body = { "name" => name }
       body.merge!(supplied({ "externalRef" => external_ref }))
+      body["defaultRegion"] = default_region unless default_region.nil?
       @client.post(
         "/v1/workspaces", body, idempotency_key: idempotency_key, retry_policy: :header_replay
       )
@@ -269,6 +274,13 @@ module SeatLayer
     # The organisation's default workspace cannot be disabled — the API answers
     # 409 +default_workspace_required+. Promote another one first.
     def update(workspace_id, fields)
+      region = fields[:default_region] || fields["defaultRegion"]
+      unless region.nil? || EVENT_HOSTING_REGIONS.include?(region)
+        raise ArgumentError, "default_region must be a supported SeatLayer Event region"
+      end
+
+      fields = fields.dup
+      fields["defaultRegion"] = fields.delete(:default_region) if fields.key?(:default_region)
       @client.patch("/v1/workspaces/#{encode(workspace_id)}", fields)
     end
   end

data/lib/seatlayer/resources.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module SeatLayer
+  EVENT_HOSTING_REGIONS = %w[
+    western-europe eastern-europe north-america-east north-america-west
+    south-america asia-pacific northeast-asia southeast-asia oceania africa middle-east
+  ].freeze
+
   # Shared plumbing for the resource namespaces.
   class Resource
     UNSET = Object.new.freeze
@@ -179,8 +184,13 @@ module SeatLayer
     def create(chart_id:, name: nil, slug: nil, starts_at: UNSET, venue: UNSET,
                external_ref: UNSET, currency: UNSET, idempotency_key: nil,
                description: UNSET, ends_at: UNSET, timezone: UNSET, locale: UNSET,
-               poster_asset_id: UNSET, mode: nil)
-      body = compact({ "chartId" => chart_id, "name" => name, "slug" => slug, "mode" => mode })
+               poster_asset_id: UNSET, mode: nil, region: nil)
+      unless region.nil? || EVENT_HOSTING_REGIONS.include?(region)
+        raise ArgumentError, "region must be a supported SeatLayer Event region"
+      end
+
+      body = compact({ "chartId" => chart_id, "name" => name, "slug" => slug,
+                       "mode" => mode, "region" => region })
       body.merge!(supplied({ "startsAt" => starts_at, "venue" => venue,
                              "externalRef" => external_ref, "currency" => currency,
                              "description" => description, "endsAt" => ends_at,

data/lib/seatlayer/seasons.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module SeatLayer
+  # Fixed Renewable Season organizer operations for trusted backends.
+  #
+  # Browser selection belongs in the distinct SeasonPicker. Give it only the
+  # show-once scoped token returned by +create_season_buyer_access_session+.
+  class Seasons < Resource
+    def list_seasons(workspace_id: nil, structure_state: nil, limit: nil, cursor: nil)
+      @client.get("/v1/seasons", compact({ "workspaceId" => workspace_id,
+                                           "structureState" => structure_state,
+                                           "limit" => limit, "cursor" => cursor }))
+    end
+
+    # Read-only compatibility preflight.
+    def validate_season(event_keys: nil, source_performance_group_keys: nil)
+      @client.post("/v1/seasons/validate",
+                   selection(event_keys, source_performance_group_keys))
+    end
+
+    def create_season(name:, event_keys: nil, source_performance_group_keys: nil,
+                      edition: UNSET, idempotency_key: nil)
+      body = selection(event_keys, source_performance_group_keys).merge("name" => name)
+      body.merge!(supplied({ "edition" => edition }))
+      @client.post("/v1/seasons", body, idempotency_key: idempotency_key,
+                                        retry_policy: :header_replay)
+    end
+
+    def retrieve_season(season_key)
+      @client.get(path(season_key))
+    end
+
+    def update_season(season_key, expected_revision:, name: nil, edition: UNSET,
+                      idempotency_key: nil)
+      body = compact({ "expectedRevision" => expected_revision, "name" => name })
+      body.merge!(supplied({ "edition" => edition }))
+      @client.mutation_with_header_replay(
+        "PATCH", path(season_key), body, idempotency_key: idempotency_key
+      )
+    end
+
+    def delete_season(season_key, idempotency_key: nil)
+      @client.mutation_with_header_replay(
+        "DELETE", path(season_key), idempotency_key: idempotency_key
+      )
+    end
+
+    def activate_season(season_key, expected_revision:)
+      lifecycle(season_key, "activate", expected_revision)
+    end
+
+    def close_season(season_key, expected_revision:)
+      lifecycle(season_key, "close", expected_revision)
+    end
+
+    def archive_season(season_key, expected_revision:)
+      lifecycle(season_key, "archive", expected_revision)
+    end
+
+    def retrieve_season_lifecycle(season_key, operation_id)
+      @client.get(path(season_key, "/lifecycle/#{encode(operation_id)}"))
+    end
+
+    def create_season_plan(season_key, name:, event_keys: nil,
+                           source_performance_group_keys: nil, idempotency_key: nil)
+      body = selection(event_keys, source_performance_group_keys).merge("name" => name)
+      @client.post(path(season_key, "/plans"), body, idempotency_key: idempotency_key,
+                                                     retry_policy: :header_replay)
+    end
+
+    def retrieve_season_plan(season_key, plan_key)
+      @client.get(path(season_key, "/plans/#{encode(plan_key)}"))
+    end
+
+    def publish_season_plan(season_key, plan_key, expected_revision:)
+      @client.post(path(season_key, "/plans/#{encode(plan_key)}/publish"),
+                   { "expectedRevision" => expected_revision })
+    end
+
+    def supersede_season_plan(season_key, plan_key, expected_revision:)
+      @client.post(path(season_key, "/plans/#{encode(plan_key)}/supersede"),
+                   { "expectedRevision" => expected_revision })
+    end
+
+    def open_season_sales(season_key, expected_revision:)
+      sales(season_key, "open", expected_revision)
+    end
+
+    def pause_season_sales(season_key, expected_revision:)
+      sales(season_key, "pause", expected_revision)
+    end
+
+    def resume_season_sales(season_key, expected_revision:)
+      sales(season_key, "resume", expected_revision)
+    end
+
+    def end_season_sales(season_key, expected_revision:)
+      sales(season_key, "end", expected_revision)
+    end
+
+    def duplicate_season_to_live(season_key, event_keys:, name: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/duplicate-to-live"),
+                   compact({ "eventKeys" => event_keys, "name" => name }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Reveal one show-once browser bearer. This call is deliberately single-attempt.
+    def create_season_buyer_access_session(season_key, allowed_origin:, include_public:,
+                                           expires_in_seconds: nil, max_quantity: UNSET,
+                                           buyer_ref: UNSET)
+      body = compact({ "allowedOrigin" => allowed_origin, "includePublic" => include_public,
+                       "expiresInSeconds" => expires_in_seconds })
+      body.merge!(supplied({ "maxQuantity" => max_quantity, "buyerRef" => buyer_ref }))
+      @client.post(path(season_key, "/buyer-access-sessions"), body)
+    end
+
+    def list_season_buyer_access_sessions(season_key, limit: nil)
+      @client.get(path(season_key, "/buyer-access-sessions"), compact({ "limit" => limit }))
+    end
+
+    def revoke_season_buyer_access_session(season_key, session_id)
+      @client.delete(path(season_key, "/buyer-access-sessions/#{encode(session_id)}"))
+    end
+
+    def retrieve_season_hold(season_key, operation_id)
+      @client.get(path(season_key, "/holds/#{encode(operation_id)}"))
+    end
+
+    def book_season_hold(season_key, operation_id, book_action_id:, booking_ref:)
+      @client.post(path(season_key, "/holds/#{encode(operation_id)}/book"),
+                   { "bookActionId" => book_action_id, "bookingRef" => booking_ref })
+    end
+
+    def retrieve_season_booking(season_key, action_id)
+      @client.get(path(season_key, "/bookings/#{encode(action_id)}"))
+    end
+
+    def cancel_season_booking(season_key, action_id, cancel_action_id:, booking_ref:,
+                              plan_activation_id:, right_disposition:)
+      @client.post(path(season_key, "/bookings/#{encode(action_id)}/cancel"),
+                   { "cancelActionId" => cancel_action_id, "bookingRef" => booking_ref,
+                     "planActivationId" => plan_activation_id,
+                     "rightDisposition" => right_disposition })
+    end
+
+    def validate_season_buyer_rehearsal(season_key)
+      @client.post(path(season_key, "/buyer-rehearsals/validate"))
+    end
+
+    def create_season_holder_import(season_key, successor_plan_activation_id:, rows:,
+                                    dry_run: UNSET, idempotency_key: nil)
+      body = { "successorPlanActivationId" => successor_plan_activation_id, "rows" => rows }
+      body.merge!(supplied({ "dryRun" => dry_run }))
+      @client.post(path(season_key, "/imports"), body, idempotency_key: idempotency_key,
+                                                       retry_policy: :header_replay)
+    end
+
+    def retrieve_season_holder_import(season_key, import_id)
+      @client.get(path(season_key, "/imports/#{encode(import_id)}"))
+    end
+
+    def create_season_renewal_offers(season_key, deadline_at:,
+                                     successor_plan_activation_id: nil, contract_ids: nil,
+                                     idempotency_key: nil)
+      body = compact({ "successorPlanActivationId" => successor_plan_activation_id,
+                       "deadlineAt" => deadline_at, "contractIds" => contract_ids })
+      @client.post(path(season_key, "/renewal-offers"), body,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    def list_season_renewal_offers(season_key)
+      @client.get(path(season_key, "/renewal-offers"))
+    end
+
+    def retrieve_season_renewal_offer(season_key, offer_id)
+      @client.get(path(season_key, "/renewal-offers/#{encode(offer_id)}"))
+    end
+
+    def extend_season_renewal_offer(season_key, offer_id, deadline_at:)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/extend"),
+                   { "deadlineAt" => deadline_at })
+    end
+
+    def inspect_season_renewal_offer(season_key, offer_id)
+      @client.get(path(season_key, "/renewal-offers/#{encode(offer_id)}/inspect"))
+    end
+
+    def commit_season_renewal_offer(season_key, offer_id, commit_action_id:, order_ref:,
+                                    booking_ref:, plan_activation_id:)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/commit"),
+                   { "commitActionId" => commit_action_id, "orderRef" => order_ref,
+                     "bookingRef" => booking_ref, "planActivationId" => plan_activation_id })
+    end
+
+    def decline_season_renewal_offer(season_key, offer_id)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/decline"), {})
+    end
+
+    def release_season_renewal_offer(season_key, offer_id)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/release"), {})
+    end
+
+    def list_season_occurrences(season_key)
+      @client.get(path(season_key, "/occurrences"))
+    end
+
+    def create_season_amendment(season_key, event_key:, kind:, starts_at: nil, name: nil,
+                                idempotency_key: nil)
+      @client.post(path(season_key, "/amendments"),
+                   compact({ "eventKey" => event_key, "kind" => kind,
+                             "startsAt" => starts_at, "name" => name }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    def list_season_amendments(season_key)
+      @client.get(path(season_key, "/amendments"))
+    end
+
+    def retrieve_season_amendment(season_key, amendment_id)
+      @client.get(path(season_key, "/amendments/#{encode(amendment_id)}"))
+    end
+
+    def retrieve_season_report(season_key)
+      @client.get(path(season_key, "/reports"))
+    end
+
+    def list_season_operations(season_key)
+      @client.get(path(season_key, "/operations"))
+    end
+
+    def retrieve_season_support_lookup(season_key, booking_ref: nil, holder_ref: nil)
+      @client.get(path(season_key, "/support-lookups"),
+                  compact({ "bookingRef" => booking_ref, "holderRef" => holder_ref }))
+    end
+
+    def list_season_outbox(season_key)
+      @client.get(path(season_key, "/outbox"))
+    end
+
+    def replay_season_outbox(season_key, occurrence_id)
+      @client.post(path(season_key, "/outbox/#{encode(occurrence_id)}/replay"), {})
+    end
+
+    def list_season_audit(season_key)
+      @client.get(path(season_key, "/audit"))
+    end
+
+    def export_season_support_snapshot(season_key)
+      @client.get(path(season_key, "/export"))
+    end
+
+    private
+
+    def path(season_key, suffix = "")
+      "/v1/seasons/#{encode(season_key)}#{suffix}"
+    end
+
+    def selection(event_keys, source_performance_group_keys)
+      compact({ "eventKeys" => event_keys,
+                "sourcePerformanceGroupKeys" => source_performance_group_keys })
+    end
+
+    def lifecycle(season_key, action, expected_revision)
+      @client.post(path(season_key, "/#{action}"), { "expectedRevision" => expected_revision })
+    end
+
+    def sales(season_key, action, expected_revision)
+      @client.post(path(season_key, "/sales/#{action}"),
+                   { "expectedRevision" => expected_revision })
+    end
+  end
+end

data/lib/seatlayer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SeatLayer
-  VERSION = "0.6.1"
+  VERSION = "0.8.0"
 end

data/lib/seatlayer.rb

@@ -7,6 +7,7 @@ require_relative "seatlayer/resources"
 require_relative "seatlayer/inventory"
 require_relative "seatlayer/channels"
 require_relative "seatlayer/performance_groups"
+require_relative "seatlayer/seasons"
 require_relative "seatlayer/webhook"
 
 # Official Ruby server SDK for the SeatLayer reserved-seating API.
@@ -21,7 +22,7 @@ module SeatLayer
   # The SeatLayer client.
   class Client
     attr_reader :charts, :events, :inventory, :channels, :performance_groups, :sessions,
-                :webhooks, :workspaces, :templates
+                :seasons, :webhooks, :workspaces, :templates
 
     def initialize(secret_key, base_url: HTTPClient::DEFAULT_BASE_URL,
                    max_retries: HTTPClient::DEFAULT_MAX_RETRIES,
@@ -34,6 +35,7 @@ module SeatLayer
       @inventory = Inventory.new(@http)
       @channels = Channels.new(@http)
       @performance_groups = PerformanceGroups.new(@http)
+      @seasons = Seasons.new(@http)
       @sessions = Sessions.new(@http)
       @templates = Templates.new(@http)
       @webhooks = Webhooks.new(@http)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seatlayer
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
 - SeatLayer
@@ -28,6 +28,7 @@ files:
 - lib/seatlayer/inventory.rb
 - lib/seatlayer/performance_groups.rb
 - lib/seatlayer/resources.rb
+- lib/seatlayer/seasons.rb
 - lib/seatlayer/version.rb
 - lib/seatlayer/webhook.rb
 homepage: https://seatlayer.io