seatlayer 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe617b9eff9a2dbeb571b81e16f8d41096b4cb4d49f35a3461f03b292316a87
-  data.tar.gz: d901b82e10dd7194b726f7c3d4b8f2d642030a1458c42ae7a851b200a9b0ef9a
+  metadata.gz: a65cc789351eb854341bf167fdedbd818035c29639e212df5312597f46e3f23c
+  data.tar.gz: 0fc4163ccaedd380264fbc53853c71c476f4bbfdb4f99180663f66c434d94b66
 SHA512:
-  metadata.gz: d12c27e2f846f0aca0f95e8cc064723f9ad5ff37a83c64a854529db34a4b4651865011e3634a4eacd48bed9214e8ee64e1bccf162db24ca21d020f035cd6f091
-  data.tar.gz: e764024fd33ae0ca89714490934a7bbac28a2527a0ccee40a1892b1d2292f6945deb575c28b69665f77fcb04dd2ba987b1ce80cdb0b512236a497386563ee9c3
+  metadata.gz: dc59365e346c8a14cf52014ca804f70aa63eabee928214906913c060bf58f4c2edb0dbb3eaec90305096b396bf2257468f444b5d8ba3f154e78f57625b125126
+  data.tar.gz: c74c63603bd068dd4566b18b1c940762de0258fbcf186b083608c263ce10ffa8a9934db69a135cdbb0d3c225a4334ecfb15a6f672e6e853c745a11d3cc9eab44

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

@@ -12,9 +12,9 @@ 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/) ·
+[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.
@@ -57,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?`.
 

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/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.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.1
+  version: 0.7.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