seatlayer 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0ac6e36b23b34e28d914944c5a15cf08dabb40f9b31466740b4b04b99cec1c6
-  data.tar.gz: cabf4e47e42d39f2fe9f9ef0d001ff8043428702982f41d4c20f04f70cd333f9
+  metadata.gz: a65cc789351eb854341bf167fdedbd818035c29639e212df5312597f46e3f23c
+  data.tar.gz: 0fc4163ccaedd380264fbc53853c71c476f4bbfdb4f99180663f66c434d94b66
 SHA512:
-  metadata.gz: eef04285447d411a1ab752e670136491716bc27284cbb5a825670ff9eca7d292de3ed473b842ce4c4a7af3925dd278353cb48683dd9029d371c03b11c76f30b0
-  data.tar.gz: f86eacb6d08d744362d0d84cc802720a4c5a04b9134b70950a1051cf4f4d1b3266744b356374895340b1c782a7fcc32e5b49a45e59e845a70bf84d0159cc6148
+  metadata.gz: dc59365e346c8a14cf52014ca804f70aa63eabee928214906913c060bf58f4c2edb0dbb3eaec90305096b396bf2257468f444b5d8ba3f154e78f57625b125126
+  data.tar.gz: c74c63603bd068dd4566b18b1c940762de0258fbcf186b083608c263ce10ffa8a9934db69a135cdbb0d3c225a4334ecfb15a6f672e6e853c745a11d3cc9eab44

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # 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
+  questions, and aligns package metadata. No API or behaviour changes.
+
 ## 0.6.0 — 2026-08-23
 
 - Added exact immutable Event configuration binding reads and compare-and-set

data/README.md

@@ -1,11 +1,20 @@
-# SeatLayer Ruby SDK
+# SeatLayer Ruby Server SDK for Reserved Seating
 
 [![CI](https://github.com/seatlayer/seatlayer-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/seatlayer/seatlayer-ruby/actions/workflows/ci.yml)
 [![Gem](https://img.shields.io/gem/v/seatlayer.svg)](https://rubygems.org/gems/seatlayer)
 [![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)
 
-Official Ruby server SDK for the [SeatLayer](https://seatlayer.io) reserved-seating API.
+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` gem on RubyGems](https://rubygems.org/gems/seatlayer) ·
+[SeatLayer server SDK documentation](https://docs.seatlayer.io/server-sdk/install/) ·
+[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/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.
@@ -48,6 +57,34 @@ Nullable event-create fields distinguish omission from an explicit reset: passin
 
 ## Test vs live
 
+## 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.
+
+
 Keys carry their own mode. `sk_test_…` keys can only touch test-mode events and `sk_live_…` only
 live ones; crossing them returns `403 mode_mismatch`, surfaced as `AuthError` with `mode_mismatch?`.
 
@@ -316,32 +353,80 @@ Some API surface is intentionally unwrapped, not merely pending:
 None of these are reachable through `request` as a supported path either — they are excluded from
 the public manifest, not just from the wrapper.
 
-## Related resources
-
-- [Server SDK guide](https://docs.seatlayer.io/server-sdk/install/)
-- [Errors, retries and idempotency](https://docs.seatlayer.io/server-sdk/reliability/)
-- [Webhook verification](https://docs.seatlayer.io/server-sdk/webhooks/)
-- [Server API reference](https://docs.seatlayer.io/server-api/events/)
-- [OpenAPI description](https://docs.seatlayer.io/openapi.json)
-- [Agent-readable documentation](https://docs.seatlayer.io/llms.txt)
-- [SeatLayer GitHub organization](https://github.com/seatlayer)
+## Frequently asked questions
+
+### How do I book seats from Ruby?
+
+Create a client with your secret key, obtain a hold id — either from the buyer's
+browser session or by holding server-side — and call `inventory.book(event_key, hold_id: ..., booking_ref: ...)`.
+`booking_ref` is your own stable order id and is the join between SeatLayer
+inventory and your commercial order, so the same reference identifies the booking
+in Booking History and when you later cancel it. For phone orders, box office, and
+comps, `inventory.book_best_available` books outright with no browser involved.
+
+### What does the server SDK do compared with the buyer SDK?
+
+The buyer SDK runs where the ticket buyer is: it renders the interactive seating
+chart, handles seat selection, and creates temporary holds. This server SDK is the
+trusted side. It authenticates with your secret key, inspects what a hold actually
+contains, prices from server-owned data, and books. Never bundle the secret key
+into a browser or a mobile app — browser surfaces get short-lived, origin-bound
+tokens that you mint here.
+
+### How do temporary holds work server-side?
+
+A hold reserves seats against concurrent buyers for a limited window.
+`inventory.retrieve_hold(event_key, hold_id)` is the authoritative answer for what is held
+and at what price, so charge from its `items` rather than from anything the browser
+sent you. When an order runs longer than the checkout window, `inventory.extend_hold`
+renews the hold instead of releasing and re-holding, which would hand the seats to
+whoever is racing for them. Bookings carry the server's exact-selection plus
+`booking_ref` safeguard, but the SDK sends each booking once — reconcile an unknown
+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.
+
+## Continue your Ruby integration
+
+- [Follow the SeatLayer server SDK guide](https://docs.seatlayer.io/server-sdk/install/)
+  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.
+- [Verify SeatLayer webhooks](https://docs.seatlayer.io/server-sdk/webhooks/)
+  to react to holds, expiry, and bookings on your server.
+- [Browse the SeatLayer server API reference](https://docs.seatlayer.io/server-api/events/)
+  for every endpoint behind this SDK.
+- [Generate clients from the SeatLayer OpenAPI description](https://docs.seatlayer.io/openapi.json)
+  or explore the raw API surface.
+- [Point AI coding agents at the SeatLayer docs index](https://docs.seatlayer.io/llms.txt)
+  (`llms.txt`) for an agent-readable map of the documentation.
+- [Explore every SeatLayer SDK on GitHub](https://github.com/seatlayer)
+  across web, mobile, and server.
 
 ### Other SeatLayer SDKs
 
-| Surface | Package |
-|---|---|
-| Browser (vanilla) | [`@seatlayer/js`](https://www.npmjs.com/package/@seatlayer/js) |
+| Surface | Package or source |
+| --- | --- |
+| JavaScript | [`@seatlayer/js`](https://www.npmjs.com/package/@seatlayer/js) |
 | React | [`@seatlayer/react`](https://www.npmjs.com/package/@seatlayer/react) |
 | React Native | [`@seatlayer/react-native`](https://www.npmjs.com/package/@seatlayer/react-native) |
 | iOS | [`seatlayer-ios`](https://github.com/seatlayer/seatlayer-ios) |
-| Android | [`seatlayer-android`](https://github.com/seatlayer/seatlayer-android) |
 | Flutter | [`seatlayer`](https://pub.dev/packages/seatlayer) |
+| Android | [`seatlayer-android`](https://github.com/seatlayer/seatlayer-android) |
 | Node.js (server) | [`@seatlayer/server`](https://www.npmjs.com/package/@seatlayer/server) |
 | Python (server) | [`seatlayer`](https://pypi.org/project/seatlayer/) |
 | PHP (server) | [`seatlayer/seatlayer-php`](https://packagist.org/packages/seatlayer/seatlayer-php) |
-| Java (server) | [`io.seatlayer:seatlayer-java`](https://central.sonatype.com/artifact/io.seatlayer/seatlayer-java/0.3.0) |
-| Go (server) | [`github.com/seatlayer/seatlayer-go`](https://pkg.go.dev/github.com/seatlayer/seatlayer-go) |
+| Ruby (server) | [`seatlayer`](https://rubygems.org/gems/seatlayer) (this package) |
 | .NET (server) | [`SeatLayer`](https://www.nuget.org/packages/SeatLayer) |
+| Java (server) | [`io.seatlayer:seatlayer-java`](https://central.sonatype.com/artifact/io.seatlayer/seatlayer-java) |
+| Go (server) | [`github.com/seatlayer/seatlayer-go`](https://pkg.go.dev/github.com/seatlayer/seatlayer-go) |
 
 ## Development
 

data/lib/seatlayer/channels.rb

@@ -63,7 +63,7 @@ module SeatLayer
     end
 
     # Explicit keywords document each security boundary carried by the token.
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable-next Metrics/ParameterLists
     def create_buyer_access_session(event_key, include_public:, allowed_origin:, channel_ids: nil,
                                     expires_in_seconds: nil, max_quantity: UNSET, buyer_ref: UNSET,
                                     partner_ref: UNSET, client_request_id: UNSET, idempotency_key: nil)
@@ -75,7 +75,6 @@ module SeatLayer
       @client.post("/v1/events/#{encode(event_key)}/buyer-access-sessions", body,
                    idempotency_key: idempotency_key)
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def list_buyer_access_sessions(event_key, limit: nil)
       @client.get("/v1/events/#{encode(event_key)}/buyer-access-sessions",
@@ -88,7 +87,7 @@ module SeatLayer
 
     # The URL and capability in this response are revealed once. Persist them
     # immediately; this mutation is deliberately never retried automatically.
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable-next Metrics/ParameterLists
     def create_access_link(event_key, channel_id, label: UNSET, expires_at: nil,
                            max_redemptions: nil, max_quantity: nil,
                            session_ttl_seconds: nil, include_public: nil, reason: nil,
@@ -101,7 +100,6 @@ module SeatLayer
       @client.post(path(event_key, "/#{encode(channel_id)}/access-links"), body,
                    idempotency_key: idempotency_key)
     end
-    # rubocop:enable Metrics/ParameterLists
 
     # Status only: the API never returns a previously revealed capability.
     def list_access_links(event_key, channel_id)

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

@@ -186,7 +186,7 @@ module SeatLayer
     # Mint a designer token so an organiser can edit a chart inside your own UI.
     # Requires a chart id that already exists — create or copy one first.
     # Explicit keywords keep each security and feature-policy boundary visible.
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable-next Metrics/ParameterLists
     def create_designer_session(workspace_id:, chart_id:, allowed_origin:,
                                 authority: nil, can_publish: nil, mode: nil,
                                 safe_mode_options: nil, features: nil, expires_in_seconds: nil)
@@ -197,7 +197,6 @@ module SeatLayer
                        "expiresInSeconds" => expires_in_seconds })
       @client.post("/v1/designer/sessions", body)
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def revoke_designer_session(session_id)
       @client.delete("/v1/designer/sessions/#{encode(session_id)}")

data/lib/seatlayer/resources.rb

@@ -175,7 +175,7 @@ module SeatLayer
       end
     end
 
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable-next Metrics/ParameterLists
     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,
@@ -190,7 +190,6 @@ module SeatLayer
         "/v1/events", body, idempotency_key: idempotency_key, retry_policy: :header_replay
       )
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def retrieve(event_key)
       @client.get("/v1/events/#{encode(event_key)}")

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.0"
+  VERSION = "0.7.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.0
+  version: 0.7.0
 platform: ruby
 authors:
 - SeatLayer
@@ -9,8 +9,9 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: 'Server-side Ruby client for SeatLayer: charts, events, holds, booking,
-  embed sessions and webhook verification, with idempotency and retries built in.'
+description: 'Server-side Ruby client for SeatLayer reserved seating: seating charts,
+  events, seat maps, holds, seat booking, embed sessions and webhook verification,
+  with idempotency and retries built in.'
 email:
 - hello@seatlayer.io
 executables: []
@@ -27,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