seatlayer 0.7.0 → 0.9.0

data/lib/seatlayer/seasons.rb

@@ -5,7 +5,36 @@ module SeatLayer
   #
   # Browser selection belongs in the distinct SeasonPicker. Give it only the
   # show-once scoped token returned by +create_season_buyer_access_session+.
+  #
+  # One thin method per public Season operation (90 of them), so the class is
+  # long by design rather than doing too much.
+  # rubocop:disable-next Metrics/ClassLength
   class Seasons < Resource
+    # The job voiding a cancelled date's tickets: "sbj_void_" and the cancel's
+    # "amendmentId". Cancelling a date starts it (a repeated cancel joins it);
+    # follow it with +retrieve_season_bulk_job+. Each Season ticket it voids is
+    # told by "season.ticket.voided" with reason "date_cancelled".
+    def self.date_cancel_void_job_id(amendment_id)
+      "sbj_void_#{amendment_id}"
+    end
+
+    # The most rows one +create_season_holder_import+ call takes for a package of
+    # +dates+ dates. Each row is fenced on every date: 100 up to 20 dates, then
+    # floor(2300 / (dates + 3)), 43 at 50. A call with more answers 422
+    # invalid_rows with "maxRows".
+    def self.holder_import_rows_per_call(dates)
+      (2300 / ([dates, 1].max + 3)).floor.clamp(1, 100)
+    end
+
+    # True for the 202 a season-seats season's date cancel (+create_season_amendment+)
+    # or past date (+mark_season_performance_past+) answers while the date is still
+    # leaving every season seat: "state" "finishing", "code" "block_date_leave_pending",
+    # with "eventKey", "shardsLeft" and "shardCount". It finishes by itself: send the
+    # same request again after Retry-After to read how it ended.
+    def self.date_leave_pending?(answer)
+      answer.is_a?(Hash) && answer["state"] == "finishing" && answer["code"] == "block_date_leave_pending"
+    end
+
     def list_seasons(workspace_id: nil, structure_state: nil, limit: nil, cursor: nil)
       @client.get("/v1/seasons", compact({ "workspaceId" => workspace_id,
                                            "structureState" => structure_state,
@@ -18,10 +47,18 @@ module SeatLayer
                    selection(event_keys, source_performance_group_keys))
     end
 
+    # Create a draft Season. +single_tickets+ true makes each date also sell its own
+    # single tickets once the Season is on sale; the default is Season only.
+    # +inventory_mode+ "block" turns season seats on for this Season; the default is
+    # "per_hold", and anything else is refused with 422 invalid_inventory_mode. Every
+    # Season answer carries "inventoryMode": how the season's seats are decided, "block"
+    # once season seats are turned on for it (inventoryMode "block" on create or update)
+    # or it sells from its block, else "per_hold".
     def create_season(name:, event_keys: nil, source_performance_group_keys: nil,
-                      edition: UNSET, idempotency_key: nil)
+                      edition: UNSET, idempotency_key: nil, single_tickets: nil, inventory_mode: nil)
       body = selection(event_keys, source_performance_group_keys).merge("name" => name)
       body.merge!(supplied({ "edition" => edition }))
+      body.merge!(compact({ "singleTickets" => single_tickets, "inventoryMode" => inventory_mode }))
       @client.post("/v1/seasons", body, idempotency_key: idempotency_key,
                                         retry_policy: :header_replay)
     end
@@ -30,10 +67,33 @@ module SeatLayer
       @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 }))
+    # Rename a draft, or set how the Season sells. +checkout_mode+ ("seatlayer" or
+    # "server") cannot go back to undecided and is fixed once a live booking exists.
+    # The cutoffs are hours (0 to 720) before a date starts; pass +nil+ to send an
+    # explicit JSON null, which means the club default (Settings › Ticket site), or
+    # until the date starts when the club has none. +audience+ "public" lists
+    # the Season on your SeatLayer website ("embed_only" does not); an ended Season
+    # cannot become public (409 sales_ended). +single_tickets+ turned on while the Season
+    # is on sale opens each upcoming date's own sales through its readiness checks; turned
+    # off, they stop. The answer's "singleTicketDates" says which dates opened or stopped,
+    # and carries "jobRefused" when its season_singles job could not start: the change
+    # still stands, and sending +single_tickets+ true again opens any date still not open.
+    # A retry with the same +expected_revision+ and +idempotency_key+ is not applied twice.
+    # +inventory_mode+ "block" turns season seats on for this Season; "per_hold" turns them
+    # off again, refused with 409 season_block_exists once seats are set aside. It does not
+    # change the Season's "revision". Refused with 409 season_block_packages (more than one
+    # package), 409 season_block_on_sale (sales already opened without season seats),
+    # 409 season_not_draft_or_active, or 422 invalid_inventory_mode.
+    def update_season( # rubocop:disable Metrics/ParameterLists
+      season_key, expected_revision:, name: nil, edition: UNSET, checkout_mode: nil,
+      transfer_cutoff_hours: UNSET, return_cutoff_hours: UNSET, audience: nil, idempotency_key: nil,
+      single_tickets: nil, inventory_mode: nil
+    )
+      body = compact({ "expectedRevision" => expected_revision, "name" => name,
+                       "checkoutMode" => checkout_mode, "audience" => audience,
+                       "singleTickets" => single_tickets, "inventoryMode" => inventory_mode })
+      body.merge!(supplied({ "edition" => edition, "transferCutoffHours" => transfer_cutoff_hours,
+                             "returnCutoffHours" => return_cutoff_hours }))
       @client.mutation_with_header_replay(
         "PATCH", path(season_key), body, idempotency_key: idempotency_key
       )
@@ -82,6 +142,11 @@ module SeatLayer
                    { "expectedRevision" => expected_revision })
     end
 
+    # Open sales. The answer's "warnings" say what is advised but not required, such
+    # as "checkout_test_missing" until a checkout test or rehearsal has passed.
+    # Refused with 409 plan_not_published or checkout_mode_not_chosen until a package
+    # is published and a checkout mode is chosen, and with 409 block_not_ready when
+    # season seats are turned on (inventory_mode "block") but the seats are not set aside yet.
     def open_season_sales(season_key, expected_revision:)
       sales(season_key, "open", expected_revision)
     end
@@ -147,6 +212,11 @@ module SeatLayer
       @client.post(path(season_key, "/buyer-rehearsals/validate"))
     end
 
+    # Import incumbent holders. Each row hash takes "rowId", "holderRef",
+    # "priorPlanActivationId", "priorContractRef" and "labels", plus optional
+    # "existingBookingRef", "holderEmail" and "holderName". A call takes at most
+    # +Seasons.holder_import_rows_per_call(dates)+ rows (100 up to 20 dates, 43 at 50);
+    # more answers 422 invalid_rows with "maxRows" on the error's +body+.
     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 }
@@ -159,6 +229,10 @@ module SeatLayer
       @client.get(path(season_key, "/imports/#{encode(import_id)}"))
     end
 
+    # Answers 201 {"offers"} for 100 contracts or fewer. Above 100 it answers 202
+    # {"job", "batchId"}: a renewal_run job makes the offers. Follow it with
+    # +retrieve_season_bulk_job+, then page the offers with +list_season_renewal_offers+.
+    # Retried with one Idempotency-Key, which answers the same job.
     def create_season_renewal_offers(season_key, deadline_at:,
                                      successor_plan_activation_id: nil, contract_ids: nil,
                                      idempotency_key: nil)
@@ -168,8 +242,10 @@ module SeatLayer
                    idempotency_key: idempotency_key, retry_policy: :header_replay)
     end
 
-    def list_season_renewal_offers(season_key)
-      @client.get(path(season_key, "/renewal-offers"))
+    # One page of renewal offers, newest first. Pass +cursor+ from the previous
+    # page's +nextCursor+ (nil on the last page); +limit+ is 1 to 100 (default 100).
+    def list_season_renewal_offers(season_key, cursor: nil, limit: nil)
+      @client.get(path(season_key, "/renewal-offers"), compact({ "cursor" => cursor, "limit" => limit }))
     end
 
     def retrieve_season_renewal_offer(season_key, offer_id)
@@ -192,8 +268,12 @@ module SeatLayer
                      "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"), {})
+    # Decline a renewal offer and release its seats at once. +reason+ (1 to 200
+    # characters) is kept on the offer as +declineReason+; a repeated decline
+    # keeps the first reason.
+    def decline_season_renewal_offer(season_key, offer_id, reason: nil)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/decline"),
+                   compact({ "reason" => reason }))
     end
 
     def release_season_renewal_offer(season_key, offer_id)
@@ -204,11 +284,23 @@ module SeatLayer
       @client.get(path(season_key, "/occurrences"))
     end
 
+    # Amend one date. +kind+ is "reschedule", "replace", "cancel_exception",
+    # "postpone" (no new time yet) or "cancel" (the date will not happen). With
+    # "cancel" only, +refund+ ("none" or "per_date") refunds each SeatLayer order's
+    # share of the date as a job, and +reason+ is kept on it. A whole-order refund
+    # is the order refund. A "cancel" also voids every live ticket for the date as a
+    # date_cancel_void job, +Seasons.date_cancel_void_job_id(amendment_id)+ (the answer
+    # does not name it); follow it with +retrieve_season_bulk_job+. A cancelled date
+    # can't be moved ("reschedule"), postponed or replaced: 409 performance_cancelled.
+    # On a season-seats season, a "cancel" first takes the date off every season seat:
+    # while that finishes the answer is a 202 (check with +Seasons.date_leave_pending?+);
+    # send the same request again to read the amendment.
     def create_season_amendment(season_key, event_key:, kind:, starts_at: nil, name: nil,
-                                idempotency_key: nil)
+                                refund: nil, reason: nil, idempotency_key: nil)
       @client.post(path(season_key, "/amendments"),
                    compact({ "eventKey" => event_key, "kind" => kind,
-                             "startsAt" => starts_at, "name" => name }),
+                             "startsAt" => starts_at, "name" => name,
+                             "refund" => refund, "reason" => reason }),
                    idempotency_key: idempotency_key, retry_policy: :header_replay)
     end
 
@@ -249,6 +341,335 @@ module SeatLayer
       @client.get(path(season_key, "/export"))
     end
 
+    # Dry-run or commit renewal rights derived from a previous Season's holders.
+    # A commit of more than 100 holders answers 202 {"job"}: a holder_import job
+    # brings them across, and its +summary+ has the same counts once it completes.
+    # Retried with one Idempotency-Key, which answers the same job.
+    def create_season_holder_import_from_season(season_key, source_season_id:,
+                                                successor_plan_activation_id:, dry_run: UNSET,
+                                                idempotency_key: nil)
+      body = { "sourceSeasonId" => source_season_id,
+               "successorPlanActivationId" => successor_plan_activation_id }
+      body.merge!(supplied({ "dryRun" => dry_run }))
+      @client.post(path(season_key, "/imports/from-season"), body,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # List the Season's performances and package membership, in every lifecycle state.
+    def list_season_performances(season_key)
+      @client.get(path(season_key, "/performances"))
+    end
+
+    # Create performances inside a draft Season from a repeat rule. Pass +nil+
+    # for +venue+ or +duration_minutes+ to send an explicit JSON null.
+    # rubocop:disable-next Metrics/ParameterLists
+    def create_season_performances(season_key, title_pattern:, timezone:, repeat:,
+                                   first_starts_at: nil, count: nil, dates: nil, venue: UNSET,
+                                   duration_minutes: UNSET, region: nil,
+                                   attach_to_plan_keys: nil, idempotency_key: nil)
+      body = compact({ "titlePattern" => title_pattern, "firstStartsAt" => first_starts_at,
+                       "timezone" => timezone, "repeat" => repeat, "count" => count,
+                       "dates" => dates, "region" => region,
+                       "attachToPlanKeys" => attach_to_plan_keys })
+      body.merge!(supplied({ "venue" => venue, "durationMinutes" => duration_minutes }))
+      @client.post(path(season_key, "/performances"), body,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Attach existing events to a draft Season as performances.
+    def attach_season_performances(season_key, event_keys:, attach_to_plan_keys: nil,
+                                   idempotency_key: nil)
+      body = compact({ "eventKeys" => event_keys, "attachToPlanKeys" => attach_to_plan_keys })
+      @client.post(path(season_key, "/performances/attach"), body,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Remove one performance from a draft Season.
+    def delete_season_performance(season_key, event_key, idempotency_key: nil)
+      @client.mutation_with_header_replay(
+        "DELETE", path(season_key, "/performances/#{encode(event_key)}"),
+        idempotency_key: idempotency_key
+      )
+    end
+
+    # Rename a draft package or change the performances it covers.
+    def update_season_plan(season_key, plan_key, name: nil, event_keys: nil, idempotency_key: nil)
+      @client.mutation_with_header_replay(
+        "PATCH", path(season_key, "/plans/#{encode(plan_key)}"),
+        compact({ "name" => name, "eventKeys" => event_keys }), idempotency_key: idempotency_key
+      )
+    end
+
+    # Delete a draft package. The API answers 204, so this returns an empty Hash.
+    def delete_season_plan(season_key, plan_key, idempotency_key: nil)
+      @client.mutation_with_header_replay(
+        "DELETE", path(season_key, "/plans/#{encode(plan_key)}"), idempotency_key: idempotency_key
+      )
+    end
+
+    # Publish a draft Season. Sends no body.
+    def publish_season(season_key, idempotency_key: nil)
+      @client.post(path(season_key, "/publish"), nil,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Run a test checkout against the Season.
+    def create_season_checkout_test(season_key, plan_key: nil, quantity: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/checkout-tests"),
+                   compact({ "planKey" => plan_key, "quantity" => quantity }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # List the Season's test checkouts.
+    def list_season_checkout_tests(season_key)
+      @client.get(path(season_key, "/checkout-tests"))
+    end
+
+    # Replace every price of one package. Each price hash takes "categoryKey" and
+    # "unitPrice" (minor units), plus an optional "priceTypeKey": "adult" (the
+    # default), "child", "concession", "senior" or "student".
+    def replace_season_package_prices(season_key, plan_key, prices:, currency: nil,
+                                      idempotency_key: nil)
+      @client.mutation_with_header_replay(
+        "PUT", path(season_key, "/plans/#{encode(plan_key)}/prices"),
+        compact({ "prices" => prices, "currency" => currency }), idempotency_key: idempotency_key
+      )
+    end
+
+    # List the prices of every package in the Season, each with its
+    # "priceTypeKey" and "priceTypeLabel".
+    def list_season_prices(season_key)
+      @client.get(path(season_key, "/prices"))
+    end
+
+    # Add one performance to a package.
+    def attach_season_plan_performance(season_key, plan_key, event_key:, idempotency_key: nil)
+      @client.post(path(season_key, "/plans/#{encode(plan_key)}/performances"),
+                   { "eventKey" => event_key },
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Remove one performance from a package.
+    def delete_season_plan_performance(season_key, plan_key, event_key, idempotency_key: nil)
+      @client.mutation_with_header_replay(
+        "DELETE", path(season_key, "/plans/#{encode(plan_key)}/performances/#{encode(event_key)}"),
+        idempotency_key: idempotency_key
+      )
+    end
+
+    # Mark a performance past so it stops blocking new Season sales. A cancelled date
+    # answers 409 performance_cancelled. On a season-seats season the date first leaves
+    # every season seat: while that finishes the answer is a 202 (check with
+    # +Seasons.date_leave_pending?+).
+    def mark_season_performance_past(season_key, event_key, force: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/performances/#{encode(event_key)}/past"),
+                   compact({ "force" => force }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Return one Season occurrence allocation to ordinary Event inventory.
+    # Single-attempt: keep +action_id+ stable and retry it yourself if needed.
+    def return_season_occurrence_inventory(season_key, event_key, action_id:, booking_ref:,
+                                           plan_activation_id:, labels:, source:)
+      @client.post(path(season_key, "/occurrences/#{encode(event_key)}/returns"),
+                   { "actionId" => action_id, "bookingRef" => booking_ref,
+                     "planActivationId" => plan_activation_id, "labels" => labels,
+                     "source" => source })
+    end
+
+    # Reclaim returned inventory for a Season occurrence. Single-attempt, like
+    # +return_season_occurrence_inventory+.
+    def reclaim_season_occurrence_inventory(season_key, event_key, action_id:, return_action_id:,
+                                            booking_ref:, plan_activation_id:, labels:, source:)
+      @client.post(path(season_key, "/occurrences/#{encode(event_key)}/reclaims"),
+                   { "actionId" => action_id, "returnActionId" => return_action_id,
+                     "bookingRef" => booking_ref, "planActivationId" => plan_activation_id,
+                     "labels" => labels, "source" => source })
+    end
+
+    # One page of Season holders. +search+ is sent as the API's +q+ parameter.
+    def list_season_holders(season_key, search: nil, status: nil, cursor: nil, limit: nil)
+      @client.get(path(season_key, "/holders"),
+                  compact({ "q" => search, "status" => status, "cursor" => cursor,
+                            "limit" => limit }))
+    end
+
+    # Refund a Season order, in full or by +amount_minor+.
+    def refund_season_order(season_key, order_id, amount_minor: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/orders/#{encode(order_id)}/refund"),
+                   compact({ "amountMinor" => amount_minor }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Cancel a Season order.
+    def cancel_season_order(season_key, order_id, reason:, note: nil, refund_confirmed: nil,
+                            used_tickets_acknowledged: nil, notify_buyer: nil, idempotency_key: nil)
+      body = compact({ "reason" => reason, "note" => note, "refundConfirmed" => refund_confirmed,
+                       "usedTicketsAcknowledged" => used_tickets_acknowledged,
+                       "notifyBuyer" => notify_buyer })
+      @client.post(path(season_key, "/orders/#{encode(order_id)}/cancel"), body,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Cancel one date of a Season order.
+    def cancel_season_order_date(season_key, order_id, event_key, action_id: nil,
+                                 idempotency_key: nil)
+      @client.post(path(season_key, "/orders/#{encode(order_id)}/dates/#{encode(event_key)}/cancel"),
+                   compact({ "actionId" => action_id }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Send a Season order's tickets again. Single-attempt: never retried automatically.
+    def resend_season_order_tickets(season_key, order_id, email: nil)
+      @client.post(path(season_key, "/orders/#{encode(order_id)}/resend"),
+                   compact({ "email" => email }))
+    end
+
+    # Read the state of hosted renewals for one page of offers, newest first. Pass
+    # +cursor+ from the previous page's +nextCursor+ (nil on the last page); +limit+
+    # is 1 to 500 (default 500).
+    def retrieve_season_hosted_renewals(season_key, cursor: nil, limit: nil)
+      @client.get(path(season_key, "/renewal-hosted"), compact({ "cursor" => cursor, "limit" => limit }))
+    end
+
+    # Replace a renewal offer's link. The new link is shown once, so this is
+    # deliberately single-attempt.
+    def rotate_season_renewal_offer_link(season_key, offer_id)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/link"))
+    end
+
+    # Set the contact on a renewal offer. Pass +nil+ to send an explicit JSON null.
+    def update_season_renewal_offer_contact(season_key, offer_id, email: UNSET, name: UNSET)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/contact"),
+                   supplied({ "email" => email, "name" => name }))
+    end
+
+    # Send renewal notices, to every open offer or only to +offer_ids+ (at most
+    # 20,000; more is refused with 422 too_many_offer_ids).
+    # +batch_id+, instead of +offer_ids+: every open offer one renewal offer batch made.
+    def create_season_renewal_notices(season_key, offer_ids: nil, batch_id: nil)
+      @client.post(path(season_key, "/renewal-notices"),
+                   compact({ "offerIds" => offer_ids, "batchId" => batch_id }))
+    end
+
+    # Send one renewal offer again. Single-attempt: never retried automatically.
+    def resend_season_renewal_offer(season_key, offer_id)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/resend"))
+    end
+
+    # What renewing an offer costs, priced as the SeatLayer checkout will charge
+    # it. +problem+ is nil when SeatLayer checkout can take the renewal now.
+    def retrieve_season_renewal_quote(season_key, offer_id)
+      @client.get(path(season_key, "/renewal-offers/#{encode(offer_id)}/quote"))
+    end
+
+    # Record that the holder means to renew, for a renewal taken by phone or at
+    # the box office, so your own checkout can commit the offer. Single-attempt;
+    # a repeat answers the same offer.
+    def create_season_renewal_intent(season_key, offer_id)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/intent"))
+    end
+
+    # Start a SeatLayer checkout that renews an offer, with no hosted page. Send
+    # the buyer to +payment.url+. Retried with one Idempotency-Key, which answers
+    # the same order.
+    def create_season_renewal_checkout(season_key, offer_id, return_url:, buyer_email: nil,
+                                       buyer_name: nil, provider: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/renewal-offers/#{encode(offer_id)}/checkout"),
+                   compact({ "returnUrl" => return_url, "buyerEmail" => buyer_email,
+                             "buyerName" => buyer_name, "provider" => provider }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Read the Season's sales report.
+    def retrieve_season_sales_report(season_key)
+      @client.get(path(season_key, "/reports/sales"))
+    end
+
+    # Read the Season's seats report.
+    def retrieve_season_seats_report(season_key)
+      @client.get(path(season_key, "/reports/seats"))
+    end
+
+    # Download the Season's holders as CSV. Returns the raw CSV text.
+    def export_season_holders_csv(season_key, search: nil, status: nil)
+      @client.get_text(path(season_key, "/reports/holders.csv"),
+                       compact({ "q" => search, "status" => status }))
+    end
+
+    # Download every Season order SeatLayer took as CSV. Returns the raw CSV text.
+    def export_season_orders_csv(season_key)
+      @client.get_text(path(season_key, "/reports/orders.csv"))
+    end
+
+    # Read the Season's seat counts.
+    def retrieve_season_seat_counts(season_key)
+      @client.get(path(season_key, "/seat-counts"))
+    end
+
+    # Refund every SeatLayer order holding a cancelled date, as a job. +amount+ is
+    # "per_date" (the date's share of each order); "full" is refused (422
+    # date_refund_per_date_only), so refund a whole order with the order refund.
+    # Retried with one Idempotency-Key, which replays the same job.
+    def refund_season_performance(season_key, event_key, amount:, reason: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/performances/#{encode(event_key)}/refunds"),
+                   compact({ "amount" => amount, "reason" => reason }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # Release the seats of every lapsed renewal offer, as a job; an offer extended
+    # before its turn is skipped and keeps its seat. Follow it with
+    # +retrieve_season_bulk_job+. Retried with one Idempotency-Key, which replays the same job.
+    def release_season_lapsed_offers(season_key, idempotency_key: nil)
+      @client.post(path(season_key, "/renewal-offers/release-lapsed"), nil,
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # List the Season's bulk jobs, newest first (100 at most).
+    def list_season_bulk_jobs(season_key)
+      @client.get(path(season_key, "/jobs"))
+    end
+
+    # Read one bulk job with its counts and up to 500 failed items.
+    def retrieve_season_bulk_job(season_key, job_id)
+      @client.get(path(season_key, "/jobs/#{encode(job_id)}"))
+    end
+
+    # Set the Season's seats aside on every date: every seat its packages price, minus
+    # +keep_for_single_tickets+ ({ "sectionIds", "categoryKeys", "labels" }). Answers 202
+    # with "job" (a season_block_set_aside job to follow with +retrieve_season_bulk_job+)
+    # and "block". On an active Season block mode turns on by itself once every date has
+    # the seats (season.block.ready); on a draft, Publish turns it on. Season seats must be
+    # on for the Season (409 season_block_not_enabled otherwise). Retried with one
+    # Idempotency-Key, which replays the same answer.
+    def set_aside_season_block(season_key, expected_revision:, keep_for_single_tickets: nil,
+                               idempotency_key: nil)
+      @client.post(path(season_key, "/block"),
+                   compact({ "expectedRevision" => expected_revision,
+                             "keepForSingleTickets" => keep_for_single_tickets }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
+    # The Season's seats set aside on every date: "block" with its "mode" ("block" once
+    # on, else "per_hold"), "state", "counts" and each date's "state".
+    def retrieve_season_block(season_key)
+      @client.get(path(season_key, "/block"))
+    end
+
+    # Release season seats to single sale: every unsold seat (+scope+ { "all" => true }),
+    # or the sections, categories or seats named. +event_keys+ limits it to those dates
+    # (left out: every date still to come); +at+ (an ISO time) releases then instead of
+    # now. Answers 202 with "job" (a season_block_release job to follow with
+    # +retrieve_season_bulk_job+) and "block". season.block.released is sent once it has
+    # run on every date. Retried with one Idempotency-Key, which replays the same release.
+    def release_season_block(season_key, expected_revision:, scope:, event_keys: nil, at: nil,
+                             reason: nil, idempotency_key: nil)
+      @client.post(path(season_key, "/block/release"),
+                   compact({ "expectedRevision" => expected_revision, "scope" => scope,
+                             "eventKeys" => event_keys, "at" => at, "reason" => reason }),
+                   idempotency_key: idempotency_key, retry_policy: :header_replay)
+    end
+
     private
 
     def path(season_key, suffix = "")

data/lib/seatlayer/version.rb

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

data/lib/seatlayer.rb

@@ -8,6 +8,9 @@ require_relative "seatlayer/inventory"
 require_relative "seatlayer/channels"
 require_relative "seatlayer/performance_groups"
 require_relative "seatlayer/seasons"
+require_relative "seatlayer/holders"
+require_relative "seatlayer/orders"
+require_relative "seatlayer/event_series"
 require_relative "seatlayer/webhook"
 
 # Official Ruby server SDK for the SeatLayer reserved-seating API.
@@ -22,7 +25,7 @@ module SeatLayer
   # The SeatLayer client.
   class Client
     attr_reader :charts, :events, :inventory, :channels, :performance_groups, :sessions,
-                :seasons, :webhooks, :workspaces, :templates
+                :seasons, :webhooks, :workspaces, :templates, :holders, :orders, :event_series
 
     def initialize(secret_key, base_url: HTTPClient::DEFAULT_BASE_URL,
                    max_retries: HTTPClient::DEFAULT_MAX_RETRIES,
@@ -36,6 +39,9 @@ module SeatLayer
       @channels = Channels.new(@http)
       @performance_groups = PerformanceGroups.new(@http)
       @seasons = Seasons.new(@http)
+      @holders = Holders.new(@http)
+      @orders = Orders.new(@http)
+      @event_series = EventSeries.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.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - SeatLayer
@@ -24,8 +24,11 @@ files:
 - lib/seatlayer.rb
 - lib/seatlayer/channels.rb
 - lib/seatlayer/errors.rb
+- lib/seatlayer/event_series.rb
+- lib/seatlayer/holders.rb
 - lib/seatlayer/http_client.rb
 - lib/seatlayer/inventory.rb
+- lib/seatlayer/orders.rb
 - lib/seatlayer/performance_groups.rb
 - lib/seatlayer/resources.rb
 - lib/seatlayer/seasons.rb
@@ -57,5 +60,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Official Ruby server SDK for the SeatLayer reserved-seating API.
+summary: 'Official Ruby server SDK for the SeatLayer reserved-seating API: seating
+  charts, seat maps, holds and seat booking.'
 test_files: []