cloudflare-ruby 0.0.1 → 0.2.0

data/lib/cloudflare/realtime_kit/analytics.rb

@@ -0,0 +1,62 @@
+module Cloudflare
+  module RealtimeKit
+    # Analytics endpoints. Not a CRUD resource — a thin namespace for the
+    # two reporting endpoints upstream exposes. Both return raw report data
+    # as a Hash; no per-resource modeling.
+    #
+    #   Cloudflare::RealtimeKit::Analytics.daywise(
+    #     app_id:     "app-1",
+    #     start_date: "2025-01-01",
+    #     end_date:   "2025-01-31"
+    #   )
+    #
+    #   Cloudflare::RealtimeKit::Analytics.livestreams_overall(
+    #     app_id:     "app-1",
+    #     start_time: "2025-01-01T00:00:00Z",
+    #     end_time:   "2025-01-31T23:59:59Z"
+    #   )
+    module Analytics
+      class << self
+        # GET /analytics/daywise — daily breakdown of meeting activity.
+        def daywise(start_date:, end_date:, app_id: nil, account_id: nil)
+          fetch("/accounts/{account_id}/realtime/kit/{app_id}/analytics/daywise",
+                app_id: app_id, account_id: account_id,
+                params: { start_date: start_date, end_date: end_date })
+        end
+
+        # GET /analytics/livestreams/overall — overall livestream metrics.
+        def livestreams_overall(start_time:, end_time:, app_id: nil, account_id: nil)
+          fetch("/accounts/{account_id}/realtime/kit/{app_id}/analytics/livestreams/overall",
+                app_id: app_id, account_id: account_id,
+                params: { start_time: start_time, end_time: end_time })
+        end
+
+        private
+          def fetch(path_template, app_id:, account_id:, params:)
+            scope    = build_scope(account_id: account_id, app_id: app_id)
+            path     = interpolate(path_template, scope)
+            response = Connection.instance.request(:get, path, params: params)
+            Resource.unwrap_envelope(response)
+          end
+
+          # Local copies of the two private helpers from Resource — Analytics
+          # isn't a Resource subclass (no instances, just a function namespace),
+          # so it can't inherit the private class methods. Falls back to
+          # +Cloudflare.account_id+ and +Cloudflare::RealtimeKit.app_id+ for
+          # the same per-process default behavior the Resource subclasses
+          # get for free.
+          def build_scope(account_id:, app_id:)
+            account = account_id || Cloudflare.account_id
+            app     = app_id     || RealtimeKit.app_id
+            raise ArgumentError, "missing required scope param: account_id" unless account
+            raise ArgumentError, "missing required scope param: app_id"     unless app
+            { account_id: account, app_id: app }
+          end
+
+          def interpolate(path, values)
+            path.gsub(/\{(\w+)\}/) { values[$1.to_sym] || raise(ArgumentError, "missing path param: #{$1}") }
+          end
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/app.rb

@@ -0,0 +1,56 @@
+module Cloudflare
+  module RealtimeKit
+    # An app in your Cloudflare RealtimeKit account. Apps are the top-level
+    # tenant — meetings, sessions, recordings, presets, webhooks, livestreams,
+    # and analytics all live underneath an app.
+    #
+    # Apps are list+create only; the API doesn't expose a member endpoint
+    # (no GET /apps/{id}, no PATCH, no DELETE).
+    #
+    #   Cloudflare.configure do |c|
+    #     c.api_token  = ENV["CLOUDFLARE_API_TOKEN"]
+    #     c.account_id = ENV["CLOUDFLARE_ACCOUNT_ID"]
+    #   end
+    #
+    #   app = Cloudflare::RealtimeKit::App.create(name: "Production")
+    #   app.id         # => "abc123"
+    #   app.name       # => "Production"
+    #   app.created_at # => Time
+    #
+    #   Cloudflare::RealtimeKit::App.all
+    class App < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/apps"
+
+      attribute :id,         String
+      attribute :name,       String
+      attribute :created_at, Time
+
+      class << self
+        # POST /accounts/{account_id}/realtime/kit/apps
+        #
+        # The create response double-wraps the app payload as
+        # +{ data: { app: {...} } }+, so we peel both layers before
+        # constructing the instance. List responses use the standard
+        # +{ data: [...] }+ envelope and don't need this dance.
+        def create(name:, account_id: nil)
+          scope    = build_scope(account_id: account_id)
+          response = Connection.instance.request(:post, interpolate(_collection_path, scope), body: { "name" => name })
+          new(unwrap_create_payload(response), scope: scope)
+        end
+
+        # GET /accounts/{account_id}/realtime/kit/apps
+        def all(account_id: nil)
+          scope    = build_scope(account_id: account_id)
+          response = Connection.instance.request(:get, interpolate(_collection_path, scope))
+          Array(unwrap_envelope(response)).map { new(_1, scope: scope) }
+        end
+
+        private
+          def unwrap_create_payload(response)
+            payload = unwrap_envelope(response)
+            payload.is_a?(Hash) && payload["app"].is_a?(Hash) ? payload["app"] : payload
+          end
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/chat.rb

@@ -0,0 +1,14 @@
+module Cloudflare
+  module RealtimeKit
+    # The persisted chat log for a historical session. Read-only singleton.
+    # Reached via +session.chat+, which auto-loads on first access.
+    #
+    #   session.chat.messages
+    class Chat < Resource
+      member_path "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/chat"
+      scope_required :app_id, :session_id
+
+      attribute :messages, Array
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/livestream.rb

@@ -0,0 +1,27 @@
+module Cloudflare
+  module RealtimeKit
+    # A standalone livestream — a broadcast outlet that exists outside any
+    # particular meeting. (For per-meeting broadcasting, use
+    # +meeting.start_livestreaming+ instead.)
+    #
+    #   livestream = Livestream.create(app_id: "app-1", name: "Conference")
+    #   livestream.active_session  # → ActiveLivestreamSession
+    class Livestream < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/livestreams"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/livestreams/{id}"
+      scope_required  :app_id
+
+      attribute :id,            String
+      attribute :name,          String
+      attribute :status,        String
+      attribute :ingest_server, String
+      attribute :stream_key,    String
+      attribute :playback_url,  String
+      attribute :disabled,      :boolean
+      attribute :created_at,    Time
+      attribute :updated_at,    Time
+
+      has_one :active_session, class_name: "Cloudflare::RealtimeKit::ActiveLivestreamSession"
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/livestream_session.rb

@@ -0,0 +1,26 @@
+module Cloudflare
+  module RealtimeKit
+    # A historical broadcast — a session-shaped record of one livestream
+    # invocation. Read-only.
+    #
+    # Two ways in:
+    #   LivestreamSession.find("ls-1", app_id: "app-1")
+    #   session.livestream_sessions.all  # session-scoped list
+    class LivestreamSession < Resource
+      # Note: the upstream path uses +livestream-session-id+ (with hyphens).
+      member_path "/accounts/{account_id}/realtime/kit/{app_id}/livestreams/sessions/{id}"
+      scope_required :app_id
+
+      attribute :id,             String
+      attribute :livestream_id,  String
+      attribute :ingest_seconds, Integer
+      attribute :viewer_seconds, Integer
+      attribute :started_time,   Time
+      attribute :stopped_time,   Time
+      attribute :invoked_time,   Time
+      attribute :err_message,    String
+      attribute :created_at,     Time
+      attribute :updated_at,     Time
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/meeting.rb

@@ -0,0 +1,82 @@
+module Cloudflare
+  module RealtimeKit
+    # A meeting room. Meetings live under an app and host one or more sessions
+    # when participants join. Use +has_many :participants+ for invitee
+    # management and +active_session+ for moderating the live session.
+    #
+    # == Lifecycle
+    #
+    #   meeting = Meeting.create(app_id: "app-1", title: "Standup")
+    #   meeting.update(title: "Daily standup")
+    #
+    # == Body fields (create / replace / update)
+    #
+    # +title+, +persist_chat+, +record_on_start+, +summarize_on_end+,
+    # +live_stream_on_start+, +session_keep_alive_time_in_secs+, +ai_config+,
+    # +recording_config+. Plus +status+ on update only.
+    #
+    # == Relations & actions
+    #
+    #   meeting.participants                  # → Relation → Participant
+    #   meeting.active_session                # → ActiveSession (loaded)
+    #   meeting.start_livestreaming(name:)    # POST /meetings/{id}/livestreams
+    #   meeting.stop_livestream               # POST /meetings/{id}/active-livestream/stop
+    class Meeting < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/meetings"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{id}"
+      scope_required  :app_id
+
+      attribute :id,                              String
+      attribute :title,                           String
+      attribute :status,                          String
+      attribute :created_at,                      Time
+      attribute :updated_at,                      Time
+      attribute :persist_chat,                    :boolean
+      attribute :record_on_start,                 :boolean
+      attribute :summarize_on_end,                :boolean
+      attribute :live_stream_on_start,            :boolean
+      attribute :session_keep_alive_time_in_secs, Integer
+
+      has_many :participants
+      has_one  :active_session
+
+      # PUT /meetings/{id} — full replacement. Mirrors +update+ but uses PUT
+      # semantics, so omitted fields revert to their defaults upstream.
+      def replace(**attrs)
+        response = Connection.instance.request(:put, member_path, body: self.class.to_wire_keys(attrs))
+        set_attrs_from_response(response)
+        self
+      end
+
+      # POST /meetings/{id}/livestreams — begin broadcasting this meeting.
+      def start_livestreaming(name: nil, video_config: nil)
+        Connection.instance.request(:post, "#{member_path}/livestreams", body: { name: name, video_config: video_config })
+      end
+
+      # GET /meetings/{id}/active-livestream — fetch the currently-running
+      # livestream attached to this meeting. Returns a +Livestream+ scoped to
+      # the same app, so you can chain regular livestream operations on it
+      # (e.g., +meeting.active_livestream.active_session+).
+      def active_livestream
+        response = Connection.instance.request(:get, "#{member_path}/active-livestream")
+        Livestream.new(response, scope: { account_id: @scope[:account_id], app_id: @scope[:app_id] })
+      end
+
+      # POST /meetings/{id}/active-livestream/stop
+      def stop_livestream
+        Connection.instance.request(:post, "#{member_path}/active-livestream/stop")
+      end
+
+      # GET /meetings/{id}/livestream — legacy "livestream-session-details"
+      # endpoint. Returns the meeting's livestream alongside a paginated list
+      # of its broadcast sessions: +{ "livestream" => {...}, "sessions" => [...] }+.
+      # Returned as a raw Hash because the response bundles two distinct
+      # shapes; the typed +Livestream+ + per-session lookup live elsewhere.
+      def livestream_details(page_no: nil, per_page: nil)
+        response = Connection.instance.request(:get, "#{member_path}/livestream",
+          params: { page_no: page_no, per_page: per_page })
+        self.class.unwrap_envelope(response)
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/participant.rb

@@ -0,0 +1,40 @@
+module Cloudflare
+  module RealtimeKit
+    # A meeting participant — an invited user with a preset (host, speaker,
+    # viewer, etc.). Created in the context of a meeting via
+    # +meeting.participants.create(...)+.
+    #
+    #   meeting.participants.create(
+    #     custom_participant_id: "u-42",
+    #     preset_name: "host_preset",
+    #     name: "Alex",
+    #     picture: "https://example.com/u/42.png"
+    #   )
+    #   participant.update(name: "Alexandra")
+    #   participant.regenerate_token
+    #   participant.destroy
+    class Participant < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/meetings/{meeting_id}/participants/{id}"
+      scope_required  :app_id, :meeting_id
+
+      attribute :id,                    String
+      attribute :name,                  String
+      attribute :picture,               String
+      attribute :preset_name,           String
+      attribute :custom_participant_id, String
+      attribute :token,                 String
+      attribute :created_at,            Time
+      attribute :updated_at,            Time
+
+      # POST /meetings/{meeting_id}/participants/{id}/token
+      # Mints a fresh token for an existing participant (e.g., when their
+      # previous token expired or was leaked).
+      def regenerate_token
+        response = Connection.instance.request(:post, "#{member_path}/token")
+        set_attrs_from_response(response)
+        self
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/preset.rb

@@ -0,0 +1,31 @@
+module Cloudflare
+  module RealtimeKit
+    # A reusable participant configuration. Presets bundle UI options,
+    # capabilities (audio/video/chat permissions), and behavior — useful for
+    # setting up host vs viewer roles once and assigning by name when
+    # creating participants.
+    #
+    #   preset = Preset.create(
+    #     app_id: "app-1",
+    #     name: "host_preset",
+    #     config: { ... },
+    #     ui:     { ... },
+    #     permissions: { ... }
+    #   )
+    #   preset.update(permissions: { ... })
+    #   preset.destroy
+    class Preset < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/presets"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/presets/{id}"
+      scope_required  :app_id
+
+      attribute :id,          String
+      attribute :name,        String
+      attribute :config,      Hash
+      attribute :ui,          Hash
+      attribute :permissions, Hash
+      attribute :created_at,  Time
+      attribute :updated_at,  Time
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/recording.rb

@@ -0,0 +1,85 @@
+module Cloudflare
+  module RealtimeKit
+    # A meeting recording. The platform supports composite recordings
+    # (one MP4 of the whole meeting, via +Recording.create+) and per-track
+    # recordings (one file per participant audio/video track, via
+    # +Recording.start_track+).
+    #
+    #   rec = Recording.create(meeting_id: "mtg-1", app_id: "app-1")
+    #
+    #   # State transitions hit one upstream endpoint with a
+    #   # body-discriminated +action+. The canonical form is +#transition+;
+    #   # +#pause+, +#resume+, +#stop+ are 1-line forwarders.
+    #   rec.transition(action: :pause)
+    #   rec.pause
+    #   rec.resume
+    #   rec.stop
+    #
+    #   Recording.active_for(meeting_id: "mtg-1", app_id: "app-1")
+    class Recording < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/recordings"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/recordings/{id}"
+      scope_required  :app_id
+
+      attribute :id,         String
+      attribute :meeting_id, String
+      attribute :status,     String
+      attribute :url,        String
+      attribute :file_size,  Integer
+      attribute :duration,   Integer
+      attribute :created_at, Time
+      attribute :updated_at, Time
+
+      # Spec-enumerated values for #transition. Exposed so callers can
+      # iterate, validate, or build CLI flags from the canonical list.
+      TRANSITIONS = %i[pause resume stop].freeze
+
+      class << self
+        # POST /recordings/track — start a multi-file (per-track) recording.
+        # Different upstream endpoint than +create+; use this when you need
+        # one media file per participant track.
+        def start_track(meeting_id:, layers:, app_id: nil, account_id: nil, max_seconds: nil)
+          scope    = build_scope(account_id: account_id, app_id: app_id)
+          path     = interpolate("/accounts/{account_id}/realtime/kit/{app_id}/recordings/track", scope)
+          response = Connection.instance.request(:post, path,
+            body: { meeting_id: meeting_id, layers: layers, max_seconds: max_seconds })
+          new(response, scope: scope)
+        end
+
+        # GET /recordings/active-recording/{meeting_id} — fetch the recording
+        # currently in progress for a meeting (404 if none).
+        def active_for(meeting_id:, app_id: nil, account_id: nil)
+          scope    = build_scope(account_id: account_id, app_id: app_id)
+          path     = interpolate("/accounts/{account_id}/realtime/kit/{app_id}/recordings/active-recording/{meeting_id}",
+                                 scope.merge(meeting_id: meeting_id))
+          response = Connection.instance.request(:get, path)
+          new(response, scope: scope)
+        end
+      end
+
+      # PUT /recordings/{id} — body-discriminated transition. Canonical 1:1
+      # mapping to the upstream operation. Validates +action+ against
+      # TRANSITIONS so a typo fails at the call site, not in the upstream
+      # 422.
+      #
+      #   recording.transition(action: :pause)
+      #   recording.transition(action: "stop")
+      def transition(action:)
+        sym = action.to_sym
+        unless TRANSITIONS.include?(sym)
+          raise ArgumentError, "action must be one of #{TRANSITIONS.inspect}, got #{action.inspect}"
+        end
+        response = Connection.instance.request(:put, member_path, body: { action: sym.to_s })
+        set_attrs_from_response(response)
+        self
+      end
+
+      # Convenience verbs — each forwards to #transition with a fixed action.
+      # The wire mapping lives in #transition; these exist for readability at
+      # call sites.
+      def pause  = transition(action: :pause)
+      def resume = transition(action: :resume)
+      def stop   = transition(action: :stop)
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/session.rb

@@ -0,0 +1,69 @@
+module Cloudflare
+  module RealtimeKit
+    # A historical session — the record of what happened when participants
+    # joined a meeting. Sessions are read-only from the SDK; they're created
+    # automatically by the platform when a meeting goes live.
+    #
+    #   session = Session.find("sess-1", app_id: "app-1")
+    #   session.participants.all
+    #   session.chat       # → Chat (loaded)
+    #   session.summary    # → Summary (loaded)
+    #   session.transcript # → Transcript (loaded)
+    #
+    # +Session.find_participant_by_peer_id+ does a reverse lookup from a
+    # peer-level identifier (e.g., what you get from a webhook payload) back
+    # to participant data, scoped only to the app — no session id needed.
+    class Session < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/sessions"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{id}"
+      scope_required  :app_id
+
+      attribute :id,                          String
+      attribute :associated_id,               String
+      attribute :type,                        String
+      attribute :status,                      String
+      attribute :meeting_display_name,        String
+      attribute :organization_id,             String
+      attribute :live_participants,           Integer
+      attribute :max_concurrent_participants, Integer
+      attribute :minutes_consumed,            Integer
+      attribute :started_at,                  Time
+      attribute :ended_at,                    Time
+      attribute :created_at,                  Time
+      attribute :updated_at,                  Time
+
+      has_many :participants, class_name: "Cloudflare::RealtimeKit::SessionParticipant"
+      has_one  :chat
+      has_one  :summary
+      has_one  :transcript
+
+      class << self
+        # GET /sessions/peer-report/{peer_id} — reverse lookup from a peer id.
+        # Returns participant-shaped data, not a session, so we expose it as a
+        # SessionParticipant instance.
+        def find_participant_by_peer_id(peer_id, app_id: nil, account_id: nil, filters: nil)
+          scope = build_scope(account_id: account_id, app_id: app_id)
+          path  = interpolate("/accounts/{account_id}/realtime/kit/{app_id}/sessions/peer-report/{peer_id}",
+                              scope.merge(peer_id: peer_id))
+          response = Connection.instance.request(:get, path, params: { filters: filters })
+          SessionParticipant.new(response, scope: scope)
+        end
+      end
+
+      # GET /sessions/{session_id}/livestream-sessions — paginated list of
+      # broadcast sessions associated with this historical session. Returns
+      # a plain Array of LivestreamSession instances (not a Relation): the
+      # per-session collection lives at a different parent path than the
+      # global +/livestreams/sessions/{id}+ that LivestreamSession.find uses,
+      # so the two endpoints don't share scope and Relation can't model them
+      # together cleanly.
+      def livestream_sessions(page_no: nil, per_page: nil)
+        response = Connection.instance.request(:get, "#{member_path}/livestream-sessions",
+          params: { page_no: page_no, per_page: per_page })
+        Array(self.class.unwrap_envelope(response)).map do |item|
+          LivestreamSession.new(item, scope: { account_id: @scope[:account_id], app_id: @scope[:app_id] })
+        end
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/session_participant.rb

@@ -0,0 +1,30 @@
+module Cloudflare
+  module RealtimeKit
+    # A participant as observed by a historical session. Distinct from
+    # +Participant+ (which is the meeting-level invitee record): a session
+    # participant carries timing data — when they joined, when they left,
+    # network/device events, etc.
+    #
+    # Read-only — the upstream spec exposes only GET endpoints for these.
+    # +session.participants.create+ raises NoMethodError before any HTTP
+    # call, citing the missing endpoint.
+    #
+    # Reached via +session.participants+ for the per-session list, or
+    # +Session.find_participant_by_peer_id(...)+ for a reverse lookup.
+    class SessionParticipant < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/participants"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/participants/{id}"
+      scope_required  :app_id, :session_id
+
+      attribute :id,                    String
+      attribute :name,                  String
+      attribute :picture,               String
+      attribute :preset_name,           String
+      attribute :custom_participant_id, String
+      attribute :joined_at,             Time
+      attribute :left_at,               Time
+
+      read_only
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/summary.rb

@@ -0,0 +1,28 @@
+module Cloudflare
+  module RealtimeKit
+    # AI-generated summary of a historical session. Reached via
+    # +session.summary+, which auto-loads on first access.
+    #
+    # Use +#generate+ to (re)trigger summary generation when one isn't yet
+    # available — e.g., the meeting ended without +summarize_on_end+ set.
+    #
+    #   session.summary.text
+    #   session.summary.generate
+    class Summary < Resource
+      member_path "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/summary"
+      scope_required :app_id, :session_id
+
+      attribute :text,       String
+      attribute :status,     String
+      attribute :created_at, Time
+      attribute :updated_at, Time
+
+      # POST /sessions/{session_id}/summary — generate a summary on demand.
+      def generate
+        response = Connection.instance.request(:post, member_path)
+        set_attrs_from_response(response)
+        self
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/transcript.rb

@@ -0,0 +1,17 @@
+module Cloudflare
+  module RealtimeKit
+    # Speech-to-text transcript of a historical session. Read-only singleton.
+    # Reached via +session.transcript+.
+    #
+    #   session.transcript.segments
+    class Transcript < Resource
+      member_path "/accounts/{account_id}/realtime/kit/{app_id}/sessions/{session_id}/transcript"
+      scope_required :app_id, :session_id
+
+      attribute :segments,   Array
+      attribute :status,     String
+      attribute :created_at, Time
+      attribute :updated_at, Time
+    end
+  end
+end

data/lib/cloudflare/realtime_kit/webhook.rb

@@ -0,0 +1,36 @@
+module Cloudflare
+  module RealtimeKit
+    # An HTTP endpoint that receives platform events. Each webhook subscribes
+    # to a list of event types and is invoked when matching events fire.
+    #
+    #   Webhook.create(
+    #     app_id: "app-1",
+    #     name:   "Recording finished",
+    #     url:    "https://example.com/hooks/realtimekit",
+    #     events: [ "recording.finished", "session.ended" ]
+    #   )
+    #   webhook.update(enabled: false)
+    #   webhook.replace(name: "...", url: "...", events: [ ... ])  # PUT
+    #   webhook.destroy
+    class Webhook < Resource
+      collection_path "/accounts/{account_id}/realtime/kit/{app_id}/webhooks"
+      member_path     "/accounts/{account_id}/realtime/kit/{app_id}/webhooks/{id}"
+      scope_required  :app_id
+
+      attribute :id,         String
+      attribute :name,       String
+      attribute :url,        String
+      attribute :events,     Array
+      attribute :enabled,    :boolean
+      attribute :created_at, Time
+      attribute :updated_at, Time
+
+      # PUT /webhooks/{id} — replace every field (vs PATCH +update+).
+      def replace(**attrs)
+        response = Connection.instance.request(:put, member_path, body: self.class.to_wire_keys(attrs))
+        set_attrs_from_response(response)
+        self
+      end
+    end
+  end
+end

data/lib/cloudflare/realtime_kit.rb

@@ -0,0 +1,40 @@
+module Cloudflare
+  # Cloudflare RealtimeKit (formerly Dyte) — managed video/audio infrastructure
+  # for meetings, livestreams, recordings, sessions, and analytics. Each
+  # resource maps to a hand-written class under this namespace.
+  #
+  # == Default app_id
+  #
+  # Most resources (Meeting, Participant, Recording, ...) live under an app.
+  # Set +app_id+ once at process boot and every call defaults to it; pass
+  # +app_id:+ per-call only to override.
+  #
+  #   Cloudflare::RealtimeKit.app_id = ENV["REALTIMEKIT_APP_ID"]
+  #
+  #   Cloudflare::RealtimeKit::Meeting.create(title: "Standup")          # uses default
+  #   Cloudflare::RealtimeKit::Meeting.find(id, app_id: "other-app-id")  # override
+  module RealtimeKit
+    class << self
+      # Default app_id used when a resource call doesn't pass one explicitly.
+      # Mirrors how +Cloudflare.account_id+ defaults the account scope.
+      attr_accessor :app_id
+    end
+
+    autoload :App,                     "cloudflare/realtime_kit/app"
+    autoload :Meeting,                 "cloudflare/realtime_kit/meeting"
+    autoload :Participant,             "cloudflare/realtime_kit/participant"
+    autoload :ActiveSession,           "cloudflare/realtime_kit/active_session"
+    autoload :Session,                 "cloudflare/realtime_kit/session"
+    autoload :SessionParticipant,      "cloudflare/realtime_kit/session_participant"
+    autoload :Chat,                    "cloudflare/realtime_kit/chat"
+    autoload :Summary,                 "cloudflare/realtime_kit/summary"
+    autoload :Transcript,              "cloudflare/realtime_kit/transcript"
+    autoload :Recording,               "cloudflare/realtime_kit/recording"
+    autoload :Preset,                  "cloudflare/realtime_kit/preset"
+    autoload :Webhook,                 "cloudflare/realtime_kit/webhook"
+    autoload :Livestream,              "cloudflare/realtime_kit/livestream"
+    autoload :LivestreamSession,       "cloudflare/realtime_kit/livestream_session"
+    autoload :ActiveLivestreamSession, "cloudflare/realtime_kit/active_livestream_session"
+    autoload :Analytics,               "cloudflare/realtime_kit/analytics"
+  end
+end