getstream-ruby 6.1.1 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f8a1dd8b4379c6af81682b352877f55c651f081265e87cc5ec08a477b19c91d
-  data.tar.gz: 7b46eb14dac0d23a0f76223244125ec4ff54ee2130f5b554fae68e363ac7ac00
+  metadata.gz: 725fbf9f73fef4a9c33f241c9911d226222041e245084e2dbca69cbc0418eaef
+  data.tar.gz: 637cc6dd6bc256959b15ae6a98e62f1131f3bfdf6183e8c3f64acd6e6cfc33d2
 SHA512:
-  metadata.gz: 4b88721605b6c6cc61769dee8c0940ad9b351676a7ed77c0ac9799f898dc3c297534dff333710617ebd4de527387b3273b66a31c7b49808d18f08f908b91d172
-  data.tar.gz: 58ccb9e4f16e22cce7dfff31c915f9c2c4c9be2a3f5a3e14ad6c31182f1ebb4da3cdecf63321ca19920abe15be0ce1a669e248ceaa80aab99c4a3413150669ea
+  metadata.gz: 21e076ab8023229dbdda7feff3405716929d315aa96c0d0478df09c3f7b27db8a6d24e9ea399782e16cc52f355807e33adcebe558e2c040acfcb66875b8d9ed8
+  data.tar.gz: 96f2ce649e6c7f40e1651696f39c7e3612ea822e93351c3a86f0ce352b854f7a4ac12e7216f95df9933754da6a107dcb2ac6aa85892c9bc453f437c5cbf252a3

data/README.md

@@ -350,18 +350,20 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/getstr
 
 ## Release Process
 
-Releases use two paths:
+Releases use two paths, both handled by `.github/workflows/release.yml`:
 
-- Default: automatic release when a PR is merged to `main`/`master`.
-- Fallback: manual release using `.github/workflows/manual-release.yml` (admin use only).
+- **Default**: automatic release when a PR is merged to `main`/`master`. The PR title (and body) drives the semver bump.
+- **Fallback**: manual release via the `Release` workflow's `workflow_dispatch` (admin use). Select a `version_bump` (`patch`/`minor`/`major`). `use_current_version=true` skips the bump and publishes whatever is already in `lib/getstream_ruby/version.rb`.
 
-Automatic semver bump rules are based on merged PR title/body:
+Automatic semver bump rules:
 
 - `feat:` -> minor
 - `fix:` (or `bug:`) -> patch
-- `feat!:` or `BREAKING CHANGE` in PR body -> major
+- `feat!:`, `<type>(scope)!:`, or `BREAKING CHANGE` in the PR body/title -> major
 
-PRs with other prefixes do not trigger a release.
+PRs with any other prefix do not trigger a release.
+
+The release pipeline runs lint (`make format-check && make lint && make security`), the unit suite (`make test`), and all three integration suites (chat, feed, video) on the merged commit before publishing to RubyGems. Each step is idempotent; a failed run can be re-dispatched from the Actions UI.
 
 ## License
 

data/lib/getstream_ruby/client.rb

@@ -13,6 +13,7 @@ require_relative 'generated/chat_client'
 require_relative 'generated/video_client'
 require_relative 'extensions/moderation_extensions'
 require_relative 'generated/feed'
+require_relative 'generated/webhook'
 require_relative 'stream_response'
 
 module GetStreamRuby
@@ -76,6 +77,52 @@ module GetStreamRuby
       GetStream::Generated::Feed.new(self, feed_group_id, feed_id)
     end
 
+    # Verify a webhook signature using this client's API secret (CHA-2961).
+    #
+    # Convenience wrapper around StreamChat::Webhook.verify_signature that
+    # supplies the secret automatically. The module-level method is still
+    # available for callers that need to verify with an arbitrary secret.
+    #
+    # @param body [String] The raw request body (already-decompressed)
+    # @param signature [String] The signature from the X-Signature header
+    # @return [Boolean] true if the signature is valid, false otherwise
+    def verify_signature(body, signature)
+      StreamChat::Webhook.verify_signature(body, signature, @configuration.api_secret)
+    end
+
+    # Verify and parse a webhook payload in one call, using this client's API
+    # secret (CHA-2961).
+    #
+    # Handles gzip-compressed bodies transparently. Raises
+    # StreamChat::Webhook::InvalidWebhookError on signature mismatch or parse
+    # failures; distinguish failure modes via the message substring.
+    #
+    # @param body [String] raw request body (possibly gzip-compressed)
+    # @param signature [String] X-Signature header value
+    # @return [Object] the typed event class instance or
+    #         StreamChat::Webhook::UnknownEvent
+    # @raise [StreamChat::Webhook::InvalidWebhookError]
+    def verify_and_parse_webhook(body, signature)
+      StreamChat::Webhook.verify_and_parse_webhook(body, signature, @configuration.api_secret)
+    end
+
+    # Decode + parse a Stream-delivered SQS message body.
+    #
+    # Convenience wrapper around StreamChat::Webhook.parse_sqs. No signature is
+    # required; SQS deliveries are authenticated via AWS IAM.
+    def parse_sqs(message_body)
+      StreamChat::Webhook.parse_sqs(message_body)
+    end
+
+    # Decode + parse a Stream-delivered SNS notification body.
+    #
+    # Accepts either the raw SNS HTTP envelope JSON or the pre-extracted Message
+    # string. Convenience wrapper around StreamChat::Webhook.parse_sns. No signature
+    # is required; SNS deliveries are authenticated via AWS IAM.
+    def parse_sns(notification_body)
+      StreamChat::Webhook.parse_sns(notification_body)
+    end
+
     # @param path [String] The API path
     # @param body [Hash] The request body
     # @return [GetStreamRuby::StreamResponse] The API response

data/lib/getstream_ruby/generated/common_client.rb

@@ -981,6 +981,32 @@ module GetStream
         )
       end
 
+      # Searches mentionable roles (user-assignable + channel-assignable, built-in and custom) by name prefix for autocomplete
+      #
+      # @param query [String]
+      # @param limit [Integer]
+      # @param name_gt [String]
+      # @param role_type [String]
+      # @param include_global_roles [Boolean]
+      # @return [Models::SearchRolesResponse]
+      def search_roles(query, limit = nil, name_gt = nil, role_type = nil, include_global_roles = nil)
+        path = '/api/v2/roles/search'
+        # Build query parameters
+        query_params = {}
+        query_params['query'] = query unless query.nil?
+        query_params['limit'] = limit unless limit.nil?
+        query_params['name_gt'] = name_gt unless name_gt.nil?
+        query_params['role_type'] = role_type unless role_type.nil?
+        query_params['include_global_roles'] = include_global_roles unless include_global_roles.nil?
+
+        # Make the API request
+        @client.make_request(
+          :get,
+          path,
+          query_params: query_params
+        )
+      end
+
       # Deletes custom role
       #
       # @param name [String]

data/lib/getstream_ruby/generated/feed.rb

@@ -17,11 +17,13 @@ module GetStream
       # Delete a single feed by its ID
       #
       # @param hard_delete [Boolean]
+      # @param purge_user_activities [Boolean]
       # @return [Models::DeleteFeedResponse]
-      def delete_feed(hard_delete = nil)
+      def delete_feed(hard_delete = nil, purge_user_activities = nil)
         # Build query parameters
         query_params = {}
         query_params['hard_delete'] = hard_delete unless hard_delete.nil?
+        query_params['purge_user_activities'] = purge_user_activities unless purge_user_activities.nil?
 
         # Delegate to the FeedsClient
         @client.feeds.delete_feed(@feed_group_id, @feed_id, query_params)

data/lib/getstream_ruby/generated/feeds_client.rb

@@ -992,8 +992,9 @@ module GetStream
       # @param feed_group_id [String]
       # @param feed_id [String]
       # @param hard_delete [Boolean]
+      # @param purge_user_activities [Boolean]
       # @return [Models::DeleteFeedResponse]
-      def delete_feed(feed_group_id, feed_id, hard_delete = nil)
+      def delete_feed(feed_group_id, feed_id, hard_delete = nil, purge_user_activities = nil)
         path = '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}'
         # Replace path parameters
         path = path.gsub('{feed_group_id}', feed_group_id.to_s)
@@ -1001,6 +1002,7 @@ module GetStream
         # Build query parameters
         query_params = {}
         query_params['hard_delete'] = hard_delete unless hard_delete.nil?
+        query_params['purge_user_activities'] = purge_user_activities unless purge_user_activities.nil?
 
         # Make the API request
         @client.make_request(

data/lib/getstream_ruby/generated/models/async_export_error_event.rb

@@ -43,7 +43,7 @@ module GetStream
           @started_at = attributes[:started_at] || attributes['started_at']
           @task_id = attributes[:task_id] || attributes['task_id']
           @custom = attributes[:custom] || attributes['custom']
-          @type = attributes[:type] || attributes['type'] || "export.users.error"
+          @type = attributes[:type] || attributes['type'] || "export.bulk_image_moderation.error"
           @received_at = attributes[:received_at] || attributes['received_at'] || nil
         end
 

data/lib/getstream_ruby/generated/models/delete_feeds_batch_request.rb

@@ -15,19 +15,24 @@ module GetStream
         # @!attribute hard_delete
         #   @return [Boolean] Whether to permanently delete the feeds instead of soft delete
         attr_accessor :hard_delete
+        # @!attribute purge_user_activities
+        #   @return [Boolean] When hard-deleting, also fully delete activities authored by each feed's owner from every other feed those activities were fanned out to. Default false preserves existing fan-out. Requires 'hard_delete' to be true; the request is rejected otherwise. Feeds with no recorded owner (created_by_id is empty) are silently skipped for the purge step — owner-matching against an empty string is a safety guard, not a wildcard.
+        attr_accessor :purge_user_activities
 
         # Initialize with attributes
         def initialize(attributes = {})
           super(attributes)
           @feeds = attributes[:feeds] || attributes['feeds']
           @hard_delete = attributes[:hard_delete] || attributes['hard_delete'] || nil
+          @purge_user_activities = attributes[:purge_user_activities] || attributes['purge_user_activities'] || nil
         end
 
         # Override field mappings for JSON serialization
         def self.json_field_mappings
           {
             feeds: 'feeds',
-            hard_delete: 'hard_delete'
+            hard_delete: 'hard_delete',
+            purge_user_activities: 'purge_user_activities'
           }
         end
       end

data/lib/getstream_ruby/generated/models/labels_request.rb

@@ -21,6 +21,9 @@ module GetStream
         # @!attribute content_type
         #   @return [String] Type of content: 'text' (default), 'message', or 'username'. Stored as-sent; only 'username' routes to the username moderation API.
         attr_accessor :content_type
+        # @!attribute dry_run
+        #   @return [Boolean] When true, run moderation and return labels without persisting the result. Useful for one-off checks (e.g. UI testers) that should not be recorded in the stored history.
+        attr_accessor :dry_run
         # @!attribute policy
         #   @return [String] Optional moderation policy key (max 128 chars)
         attr_accessor :policy
@@ -35,6 +38,7 @@ module GetStream
           @category = attributes[:category] || attributes['category'] || nil
           @content_id = attributes[:content_id] || attributes['content_id'] || nil
           @content_type = attributes[:content_type] || attributes['content_type'] || nil
+          @dry_run = attributes[:dry_run] || attributes['dry_run'] || nil
           @policy = attributes[:policy] || attributes['policy'] || nil
           @user_id = attributes[:user_id] || attributes['user_id'] || nil
         end
@@ -46,6 +50,7 @@ module GetStream
             category: 'category',
             content_id: 'content_id',
             content_type: 'content_type',
+            dry_run: 'dry_run',
             policy: 'policy',
             user_id: 'user_id'
           }

data/lib/getstream_ruby/generated/models/query_bookmarks_request.rb

@@ -21,12 +21,18 @@ module GetStream
         # @!attribute prev
         #   @return [String]
         attr_accessor :prev
+        # @!attribute user_id
+        #   @return [String]
+        attr_accessor :user_id
         # @!attribute sort
         #   @return [Array<SortParamRequest>] Sorting parameters for the query
         attr_accessor :sort
         # @!attribute filter
         #   @return [Object] Filters to apply to the query
         attr_accessor :filter
+        # @!attribute user
+        #   @return [UserRequest]
+        attr_accessor :user
 
         # Initialize with attributes
         def initialize(attributes = {})
@@ -35,8 +41,10 @@ module GetStream
           @limit = attributes[:limit] || attributes['limit'] || nil
           @next = attributes[:next] || attributes['next'] || nil
           @prev = attributes[:prev] || attributes['prev'] || nil
+          @user_id = attributes[:user_id] || attributes['user_id'] || nil
           @sort = attributes[:sort] || attributes['sort'] || nil
           @filter = attributes[:filter] || attributes['filter'] || nil
+          @user = attributes[:user] || attributes['user'] || nil
         end
 
         # Override field mappings for JSON serialization
@@ -46,8 +54,10 @@ module GetStream
             limit: 'limit',
             next: 'next',
             prev: 'prev',
+            user_id: 'user_id',
             sort: 'sort',
-            filter: 'filter'
+            filter: 'filter',
+            user: 'user'
           }
         end
       end

data/lib/getstream_ruby/generated/models/search_roles_response.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Code generated by GetStream internal OpenAPI code generator. DO NOT EDIT.
+
+module GetStream
+  module Generated
+    module Models
+      # 
+      class SearchRolesResponse < GetStream::BaseModel
+
+        # Model attributes
+        # @!attribute duration
+        #   @return [String]
+        attr_accessor :duration
+        # @!attribute roles
+        #   @return [Array<Role>] Matching roles, sorted ascending by name
+        attr_accessor :roles
+
+        # Initialize with attributes
+        def initialize(attributes = {})
+          super(attributes)
+          @duration = attributes[:duration] || attributes['duration']
+          @roles = attributes[:roles] || attributes['roles']
+        end
+
+        # Override field mappings for JSON serialization
+        def self.json_field_mappings
+          {
+            duration: 'duration',
+            roles: 'roles'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/getstream_ruby/generated/webhook.rb

@@ -1,7 +1,10 @@
 # Code generated by GetStream internal OpenAPI code generator. DO NOT EDIT.
 
-require 'openssl'
+require 'base64'
 require 'json'
+require 'openssl'
+require 'time'
+require 'zlib'
 require_relative 'models/activity_added_event'
 require_relative 'models/activity_deleted_event'
 require_relative 'models/activity_feedback_event'
@@ -169,6 +172,47 @@ require_relative 'models/user_updated_event'
 
 module StreamChat
   module Webhook
+    # Raised for every webhook handling failure: signature mismatch, invalid
+    # JSON, missing/non-string +type+ field, gzip-prefixed body that fails to
+    # decompress, invalid base64 in a queue body, or a malformed SNS envelope.
+    #
+    # Rescue this single class for any webhook problem; filter on the message
+    # text or against the failure-mode constants below to differentiate.
+    class InvalidWebhookError < StandardError
+      SIGNATURE_MISMATCH = 'signature mismatch'
+      INVALID_BASE64 = 'invalid base64 encoding'
+      GZIP_FAILED = 'gzip decompression failed'
+      INVALID_JSON = 'invalid JSON payload'
+    end
+
+    # Returned by parse_event when the type discriminator is well-formed but
+    # unknown to this SDK version.
+    #
+    # Stable forward-compat surface: backend may add new event types before this
+    # SDK is regenerated. Switch on the returned object's class and include
+    # UnknownEvent as a fallback case.
+    #
+    # @!attribute [r] type
+    #   @return [String] the unrecognized discriminator value
+    # @!attribute [r] created_at
+    #   @return [Time, nil] parsed timestamp from the envelope, or nil if missing/unparseable
+    # @!attribute [r] raw
+    #   @return [Hash] the full parsed JSON hash for inspection
+    class UnknownEvent
+      attr_reader :type, :created_at, :raw
+
+      def initialize(type:, created_at: nil, raw: {})
+        @type = type
+        @created_at = created_at
+        @raw = raw
+      end
+    end
+
+    # gzip magic prefix (RFC 1952 §2.3.1). JSON cannot start with these bytes,
+    # so this gives unambiguous detection for Stream's always-JSON payloads.
+    GZIP_MAGIC = "\x1F\x8B".b.freeze
+    private_constant :GZIP_MAGIC
+
     # Webhook event type constants
     EVENT_TYPE_WILDCARD = '*'
     EVENT_TYPE_APPEAL_ACCEPTED = 'appeal.accepted'
@@ -349,6 +393,9 @@ module StreamChat
 
     # Deserialize a raw webhook payload into a typed event object.
     #
+    # Throws on unknown event types. For forward-compatible parsing that returns
+    # an {UnknownEvent} on unrecognized discriminators, use {parse_event}.
+    #
     # @param raw_event [String, Hash] The raw webhook payload
     # @return [Object] A typed event object corresponding to the event type
     # @raise [ArgumentError] if the event type is unknown or deserialization fails
@@ -383,339 +430,339 @@ module StreamChat
     private_class_method def self.event_class_for_type(event_type)
       case event_type
       when '*'
-        StreamChat::CustomEvent
+        GetStream::Generated::Models::CustomEvent
       when 'appeal.accepted'
-        StreamChat::AppealAcceptedEvent
+        GetStream::Generated::Models::AppealAcceptedEvent
       when 'appeal.created'
-        StreamChat::AppealCreatedEvent
+        GetStream::Generated::Models::AppealCreatedEvent
       when 'appeal.rejected'
-        StreamChat::AppealRejectedEvent
+        GetStream::Generated::Models::AppealRejectedEvent
       when 'call.accepted'
-        StreamChat::CallAcceptedEvent
+        GetStream::Generated::Models::CallAcceptedEvent
       when 'call.blocked_user'
-        StreamChat::BlockedUserEvent
+        GetStream::Generated::Models::BlockedUserEvent
       when 'call.closed_caption'
-        StreamChat::ClosedCaptionEvent
+        GetStream::Generated::Models::ClosedCaptionEvent
       when 'call.closed_captions_failed'
-        StreamChat::CallClosedCaptionsFailedEvent
+        GetStream::Generated::Models::CallClosedCaptionsFailedEvent
       when 'call.closed_captions_started'
-        StreamChat::CallClosedCaptionsStartedEvent
+        GetStream::Generated::Models::CallClosedCaptionsStartedEvent
       when 'call.closed_captions_stopped'
-        StreamChat::CallClosedCaptionsStoppedEvent
+        GetStream::Generated::Models::CallClosedCaptionsStoppedEvent
       when 'call.created'
-        StreamChat::CallCreatedEvent
+        GetStream::Generated::Models::CallCreatedEvent
       when 'call.deleted'
-        StreamChat::CallDeletedEvent
+        GetStream::Generated::Models::CallDeletedEvent
       when 'call.dtmf'
-        StreamChat::CallDTMFEvent
+        GetStream::Generated::Models::CallDTMFEvent
       when 'call.ended'
-        StreamChat::CallEndedEvent
+        GetStream::Generated::Models::CallEndedEvent
       when 'call.frame_recording_failed'
-        StreamChat::CallFrameRecordingFailedEvent
+        GetStream::Generated::Models::CallFrameRecordingFailedEvent
       when 'call.frame_recording_ready'
-        StreamChat::CallFrameRecordingFrameReadyEvent
+        GetStream::Generated::Models::CallFrameRecordingFrameReadyEvent
       when 'call.frame_recording_started'
-        StreamChat::CallFrameRecordingStartedEvent
+        GetStream::Generated::Models::CallFrameRecordingStartedEvent
       when 'call.frame_recording_stopped'
-        StreamChat::CallFrameRecordingStoppedEvent
+        GetStream::Generated::Models::CallFrameRecordingStoppedEvent
       when 'call.hls_broadcasting_failed'
-        StreamChat::CallHLSBroadcastingFailedEvent
+        GetStream::Generated::Models::CallHLSBroadcastingFailedEvent
       when 'call.hls_broadcasting_started'
-        StreamChat::CallHLSBroadcastingStartedEvent
+        GetStream::Generated::Models::CallHLSBroadcastingStartedEvent
       when 'call.hls_broadcasting_stopped'
-        StreamChat::CallHLSBroadcastingStoppedEvent
+        GetStream::Generated::Models::CallHLSBroadcastingStoppedEvent
       when 'call.kicked_user'
-        StreamChat::KickedUserEvent
+        GetStream::Generated::Models::KickedUserEvent
       when 'call.live_started'
-        StreamChat::CallLiveStartedEvent
+        GetStream::Generated::Models::CallLiveStartedEvent
       when 'call.member_added'
-        StreamChat::CallMemberAddedEvent
+        GetStream::Generated::Models::CallMemberAddedEvent
       when 'call.member_removed'
-        StreamChat::CallMemberRemovedEvent
+        GetStream::Generated::Models::CallMemberRemovedEvent
       when 'call.member_updated'
-        StreamChat::CallMemberUpdatedEvent
+        GetStream::Generated::Models::CallMemberUpdatedEvent
       when 'call.member_updated_permission'
-        StreamChat::CallMemberUpdatedPermissionEvent
+        GetStream::Generated::Models::CallMemberUpdatedPermissionEvent
       when 'call.missed'
-        StreamChat::CallMissedEvent
+        GetStream::Generated::Models::CallMissedEvent
       when 'call.moderation_blur'
-        StreamChat::CallModerationBlurEvent
+        GetStream::Generated::Models::CallModerationBlurEvent
       when 'call.moderation_warning'
-        StreamChat::CallModerationWarningEvent
+        GetStream::Generated::Models::CallModerationWarningEvent
       when 'call.notification'
-        StreamChat::CallNotificationEvent
+        GetStream::Generated::Models::CallNotificationEvent
       when 'call.permission_request'
-        StreamChat::PermissionRequestEvent
+        GetStream::Generated::Models::PermissionRequestEvent
       when 'call.permissions_updated'
-        StreamChat::UpdatedCallPermissionsEvent
+        GetStream::Generated::Models::UpdatedCallPermissionsEvent
       when 'call.reaction_new'
-        StreamChat::CallReactionEvent
+        GetStream::Generated::Models::CallReactionEvent
       when 'call.recording_failed'
-        StreamChat::CallRecordingFailedEvent
+        GetStream::Generated::Models::CallRecordingFailedEvent
       when 'call.recording_ready'
-        StreamChat::CallRecordingReadyEvent
+        GetStream::Generated::Models::CallRecordingReadyEvent
       when 'call.recording_started'
-        StreamChat::CallRecordingStartedEvent
+        GetStream::Generated::Models::CallRecordingStartedEvent
       when 'call.recording_stopped'
-        StreamChat::CallRecordingStoppedEvent
+        GetStream::Generated::Models::CallRecordingStoppedEvent
       when 'call.rejected'
-        StreamChat::CallRejectedEvent
+        GetStream::Generated::Models::CallRejectedEvent
       when 'call.ring'
-        StreamChat::CallRingEvent
+        GetStream::Generated::Models::CallRingEvent
       when 'call.rtmp_broadcast_failed'
-        StreamChat::CallRtmpBroadcastFailedEvent
+        GetStream::Generated::Models::CallRtmpBroadcastFailedEvent
       when 'call.rtmp_broadcast_started'
-        StreamChat::CallRtmpBroadcastStartedEvent
+        GetStream::Generated::Models::CallRtmpBroadcastStartedEvent
       when 'call.rtmp_broadcast_stopped'
-        StreamChat::CallRtmpBroadcastStoppedEvent
+        GetStream::Generated::Models::CallRtmpBroadcastStoppedEvent
       when 'call.session_ended'
-        StreamChat::CallSessionEndedEvent
+        GetStream::Generated::Models::CallSessionEndedEvent
       when 'call.session_participant_count_updated'
-        StreamChat::CallSessionParticipantCountsUpdatedEvent
+        GetStream::Generated::Models::CallSessionParticipantCountsUpdatedEvent
       when 'call.session_participant_joined'
-        StreamChat::CallSessionParticipantJoinedEvent
+        GetStream::Generated::Models::CallSessionParticipantJoinedEvent
       when 'call.session_participant_left'
-        StreamChat::CallSessionParticipantLeftEvent
+        GetStream::Generated::Models::CallSessionParticipantLeftEvent
       when 'call.session_started'
-        StreamChat::CallSessionStartedEvent
+        GetStream::Generated::Models::CallSessionStartedEvent
       when 'call.stats_report_ready'
-        StreamChat::CallStatsReportReadyEvent
+        GetStream::Generated::Models::CallStatsReportReadyEvent
       when 'call.transcription_failed'
-        StreamChat::CallTranscriptionFailedEvent
+        GetStream::Generated::Models::CallTranscriptionFailedEvent
       when 'call.transcription_ready'
-        StreamChat::CallTranscriptionReadyEvent
+        GetStream::Generated::Models::CallTranscriptionReadyEvent
       when 'call.transcription_started'
-        StreamChat::CallTranscriptionStartedEvent
+        GetStream::Generated::Models::CallTranscriptionStartedEvent
       when 'call.transcription_stopped'
-        StreamChat::CallTranscriptionStoppedEvent
+        GetStream::Generated::Models::CallTranscriptionStoppedEvent
       when 'call.unblocked_user'
-        StreamChat::UnblockedUserEvent
+        GetStream::Generated::Models::UnblockedUserEvent
       when 'call.updated'
-        StreamChat::CallUpdatedEvent
+        GetStream::Generated::Models::CallUpdatedEvent
       when 'call.user_feedback_submitted'
-        StreamChat::CallUserFeedbackSubmittedEvent
+        GetStream::Generated::Models::CallUserFeedbackSubmittedEvent
       when 'call.user_muted'
-        StreamChat::CallUserMutedEvent
+        GetStream::Generated::Models::CallUserMutedEvent
       when 'campaign.completed'
-        StreamChat::CampaignCompletedEvent
+        GetStream::Generated::Models::CampaignCompletedEvent
       when 'campaign.started'
-        StreamChat::CampaignStartedEvent
+        GetStream::Generated::Models::CampaignStartedEvent
       when 'channel.created'
-        StreamChat::ChannelCreatedEvent
+        GetStream::Generated::Models::ChannelCreatedEvent
       when 'channel.deleted'
-        StreamChat::ChannelDeletedEvent
+        GetStream::Generated::Models::ChannelDeletedEvent
       when 'channel.frozen'
-        StreamChat::ChannelFrozenEvent
+        GetStream::Generated::Models::ChannelFrozenEvent
       when 'channel.hidden'
-        StreamChat::ChannelHiddenEvent
+        GetStream::Generated::Models::ChannelHiddenEvent
       when 'channel.max_streak_changed'
-        StreamChat::MaxStreakChangedEvent
+        GetStream::Generated::Models::MaxStreakChangedEvent
       when 'channel.muted'
-        StreamChat::ChannelMutedEvent
+        GetStream::Generated::Models::ChannelMutedEvent
       when 'channel.truncated'
-        StreamChat::ChannelTruncatedEvent
+        GetStream::Generated::Models::ChannelTruncatedEvent
       when 'channel.unfrozen'
-        StreamChat::ChannelUnFrozenEvent
+        GetStream::Generated::Models::ChannelUnFrozenEvent
       when 'channel.unmuted'
-        StreamChat::ChannelUnmutedEvent
+        GetStream::Generated::Models::ChannelUnmutedEvent
       when 'channel.updated'
-        StreamChat::ChannelUpdatedEvent
+        GetStream::Generated::Models::ChannelUpdatedEvent
       when 'channel.visible'
-        StreamChat::ChannelVisibleEvent
+        GetStream::Generated::Models::ChannelVisibleEvent
       when 'channel_batch_update.completed'
-        StreamChat::ChannelBatchCompletedEvent
+        GetStream::Generated::Models::ChannelBatchCompletedEvent
       when 'channel_batch_update.started'
-        StreamChat::ChannelBatchStartedEvent
+        GetStream::Generated::Models::ChannelBatchStartedEvent
       when 'custom'
-        StreamChat::CustomVideoEvent
+        GetStream::Generated::Models::CustomVideoEvent
       when 'export.bulk_image_moderation.error'
-        StreamChat::AsyncExportErrorEvent
+        GetStream::Generated::Models::AsyncExportErrorEvent
       when 'export.bulk_image_moderation.success'
-        StreamChat::AsyncBulkImageModerationEvent
+        GetStream::Generated::Models::AsyncBulkImageModerationEvent
       when 'export.channels.error'
-        StreamChat::AsyncExportErrorEvent
+        GetStream::Generated::Models::AsyncExportErrorEvent
       when 'export.channels.success'
-        StreamChat::AsyncExportChannelsEvent
+        GetStream::Generated::Models::AsyncExportChannelsEvent
       when 'export.moderation_logs.error'
-        StreamChat::AsyncExportErrorEvent
+        GetStream::Generated::Models::AsyncExportErrorEvent
       when 'export.moderation_logs.success'
-        StreamChat::AsyncExportModerationLogsEvent
+        GetStream::Generated::Models::AsyncExportModerationLogsEvent
       when 'export.users.error'
-        StreamChat::AsyncExportErrorEvent
+        GetStream::Generated::Models::AsyncExportErrorEvent
       when 'export.users.success'
-        StreamChat::AsyncExportUsersEvent
+        GetStream::Generated::Models::AsyncExportUsersEvent
       when 'feeds.activity.added'
-        StreamChat::ActivityAddedEvent
+        GetStream::Generated::Models::ActivityAddedEvent
       when 'feeds.activity.deleted'
-        StreamChat::ActivityDeletedEvent
+        GetStream::Generated::Models::ActivityDeletedEvent
       when 'feeds.activity.feedback'
-        StreamChat::ActivityFeedbackEvent
+        GetStream::Generated::Models::ActivityFeedbackEvent
       when 'feeds.activity.marked'
-        StreamChat::ActivityMarkEvent
+        GetStream::Generated::Models::ActivityMarkEvent
       when 'feeds.activity.pinned'
-        StreamChat::ActivityPinnedEvent
+        GetStream::Generated::Models::ActivityPinnedEvent
       when 'feeds.activity.reaction.added'
-        StreamChat::ActivityReactionAddedEvent
+        GetStream::Generated::Models::ActivityReactionAddedEvent
       when 'feeds.activity.reaction.deleted'
-        StreamChat::ActivityReactionDeletedEvent
+        GetStream::Generated::Models::ActivityReactionDeletedEvent
       when 'feeds.activity.reaction.updated'
-        StreamChat::ActivityReactionUpdatedEvent
+        GetStream::Generated::Models::ActivityReactionUpdatedEvent
       when 'feeds.activity.removed_from_feed'
-        StreamChat::ActivityRemovedFromFeedEvent
+        GetStream::Generated::Models::ActivityRemovedFromFeedEvent
       when 'feeds.activity.restored'
-        StreamChat::ActivityRestoredEvent
+        GetStream::Generated::Models::ActivityRestoredEvent
       when 'feeds.activity.unpinned'
-        StreamChat::ActivityUnpinnedEvent
+        GetStream::Generated::Models::ActivityUnpinnedEvent
       when 'feeds.activity.updated'
-        StreamChat::ActivityUpdatedEvent
+        GetStream::Generated::Models::ActivityUpdatedEvent
       when 'feeds.bookmark.added'
-        StreamChat::BookmarkAddedEvent
+        GetStream::Generated::Models::BookmarkAddedEvent
       when 'feeds.bookmark.deleted'
-        StreamChat::BookmarkDeletedEvent
+        GetStream::Generated::Models::BookmarkDeletedEvent
       when 'feeds.bookmark.updated'
-        StreamChat::BookmarkUpdatedEvent
+        GetStream::Generated::Models::BookmarkUpdatedEvent
       when 'feeds.bookmark_folder.deleted'
-        StreamChat::BookmarkFolderDeletedEvent
+        GetStream::Generated::Models::BookmarkFolderDeletedEvent
       when 'feeds.bookmark_folder.updated'
-        StreamChat::BookmarkFolderUpdatedEvent
+        GetStream::Generated::Models::BookmarkFolderUpdatedEvent
       when 'feeds.comment.added'
-        StreamChat::CommentAddedEvent
+        GetStream::Generated::Models::CommentAddedEvent
       when 'feeds.comment.deleted'
-        StreamChat::CommentDeletedEvent
+        GetStream::Generated::Models::CommentDeletedEvent
       when 'feeds.comment.reaction.added'
-        StreamChat::CommentReactionAddedEvent
+        GetStream::Generated::Models::CommentReactionAddedEvent
       when 'feeds.comment.reaction.deleted'
-        StreamChat::CommentReactionDeletedEvent
+        GetStream::Generated::Models::CommentReactionDeletedEvent
       when 'feeds.comment.reaction.updated'
-        StreamChat::CommentReactionUpdatedEvent
+        GetStream::Generated::Models::CommentReactionUpdatedEvent
       when 'feeds.comment.restored'
-        StreamChat::CommentRestoredEvent
+        GetStream::Generated::Models::CommentRestoredEvent
       when 'feeds.comment.updated'
-        StreamChat::CommentUpdatedEvent
+        GetStream::Generated::Models::CommentUpdatedEvent
       when 'feeds.feed.created'
-        StreamChat::FeedCreatedEvent
+        GetStream::Generated::Models::FeedCreatedEvent
       when 'feeds.feed.deleted'
-        StreamChat::FeedDeletedEvent
+        GetStream::Generated::Models::FeedDeletedEvent
       when 'feeds.feed.updated'
-        StreamChat::FeedUpdatedEvent
+        GetStream::Generated::Models::FeedUpdatedEvent
       when 'feeds.feed_group.changed'
-        StreamChat::FeedGroupChangedEvent
+        GetStream::Generated::Models::FeedGroupChangedEvent
       when 'feeds.feed_group.deleted'
-        StreamChat::FeedGroupDeletedEvent
+        GetStream::Generated::Models::FeedGroupDeletedEvent
       when 'feeds.feed_group.restored'
-        StreamChat::FeedGroupRestoredEvent
+        GetStream::Generated::Models::FeedGroupRestoredEvent
       when 'feeds.feed_member.added'
-        StreamChat::FeedMemberAddedEvent
+        GetStream::Generated::Models::FeedMemberAddedEvent
       when 'feeds.feed_member.removed'
-        StreamChat::FeedMemberRemovedEvent
+        GetStream::Generated::Models::FeedMemberRemovedEvent
       when 'feeds.feed_member.updated'
-        StreamChat::FeedMemberUpdatedEvent
+        GetStream::Generated::Models::FeedMemberUpdatedEvent
       when 'feeds.follow.created'
-        StreamChat::FollowCreatedEvent
+        GetStream::Generated::Models::FollowCreatedEvent
       when 'feeds.follow.deleted'
-        StreamChat::FollowDeletedEvent
+        GetStream::Generated::Models::FollowDeletedEvent
       when 'feeds.follow.updated'
-        StreamChat::FollowUpdatedEvent
+        GetStream::Generated::Models::FollowUpdatedEvent
       when 'feeds.notification_feed.updated'
-        StreamChat::NotificationFeedUpdatedEvent
+        GetStream::Generated::Models::NotificationFeedUpdatedEvent
       when 'feeds.stories_feed.updated'
-        StreamChat::StoriesFeedUpdatedEvent
+        GetStream::Generated::Models::StoriesFeedUpdatedEvent
       when 'flag.updated'
-        StreamChat::FlagUpdatedEvent
+        GetStream::Generated::Models::FlagUpdatedEvent
       when 'ingress.error'
-        StreamChat::IngressErrorEvent
+        GetStream::Generated::Models::IngressErrorEvent
       when 'ingress.started'
-        StreamChat::IngressStartedEvent
+        GetStream::Generated::Models::IngressStartedEvent
       when 'ingress.stopped'
-        StreamChat::IngressStoppedEvent
+        GetStream::Generated::Models::IngressStoppedEvent
       when 'member.added'
-        StreamChat::MemberAddedEvent
+        GetStream::Generated::Models::MemberAddedEvent
       when 'member.removed'
-        StreamChat::MemberRemovedEvent
+        GetStream::Generated::Models::MemberRemovedEvent
       when 'member.updated'
-        StreamChat::MemberUpdatedEvent
+        GetStream::Generated::Models::MemberUpdatedEvent
       when 'message.deleted'
-        StreamChat::MessageDeletedEvent
+        GetStream::Generated::Models::MessageDeletedEvent
       when 'message.flagged'
-        StreamChat::MessageFlaggedEvent
+        GetStream::Generated::Models::MessageFlaggedEvent
       when 'message.new'
-        StreamChat::MessageNewEvent
+        GetStream::Generated::Models::MessageNewEvent
       when 'message.pending'
-        StreamChat::PendingMessageEvent
+        GetStream::Generated::Models::PendingMessageEvent
       when 'message.read'
-        StreamChat::MessageReadEvent
+        GetStream::Generated::Models::MessageReadEvent
       when 'message.unblocked'
-        StreamChat::MessageUnblockedEvent
+        GetStream::Generated::Models::MessageUnblockedEvent
       when 'message.undeleted'
-        StreamChat::MessageUndeletedEvent
+        GetStream::Generated::Models::MessageUndeletedEvent
       when 'message.updated'
-        StreamChat::MessageUpdatedEvent
+        GetStream::Generated::Models::MessageUpdatedEvent
       when 'moderation.custom_action'
-        StreamChat::ModerationCustomActionEvent
+        GetStream::Generated::Models::ModerationCustomActionEvent
       when 'moderation.flagged'
-        StreamChat::ModerationFlaggedEvent
+        GetStream::Generated::Models::ModerationFlaggedEvent
       when 'moderation.mark_reviewed'
-        StreamChat::ModerationMarkReviewedEvent
+        GetStream::Generated::Models::ModerationMarkReviewedEvent
       when 'moderation_check.completed'
-        StreamChat::ModerationCheckCompletedEvent
+        GetStream::Generated::Models::ModerationCheckCompletedEvent
       when 'moderation_rule.triggered'
-        StreamChat::ModerationRulesTriggeredEvent
+        GetStream::Generated::Models::ModerationRulesTriggeredEvent
       when 'notification.mark_unread'
-        StreamChat::NotificationMarkUnreadEvent
+        GetStream::Generated::Models::NotificationMarkUnreadEvent
       when 'notification.reminder_due'
-        StreamChat::ReminderNotificationEvent
+        GetStream::Generated::Models::ReminderNotificationEvent
       when 'notification.thread_message_new'
-        StreamChat::NotificationThreadMessageNewEvent
+        GetStream::Generated::Models::NotificationThreadMessageNewEvent
       when 'reaction.deleted'
-        StreamChat::ReactionDeletedEvent
+        GetStream::Generated::Models::ReactionDeletedEvent
       when 'reaction.new'
-        StreamChat::ReactionNewEvent
+        GetStream::Generated::Models::ReactionNewEvent
       when 'reaction.updated'
-        StreamChat::ReactionUpdatedEvent
+        GetStream::Generated::Models::ReactionUpdatedEvent
       when 'reminder.created'
-        StreamChat::ReminderCreatedEvent
+        GetStream::Generated::Models::ReminderCreatedEvent
       when 'reminder.deleted'
-        StreamChat::ReminderDeletedEvent
+        GetStream::Generated::Models::ReminderDeletedEvent
       when 'reminder.updated'
-        StreamChat::ReminderUpdatedEvent
+        GetStream::Generated::Models::ReminderUpdatedEvent
       when 'review_queue_item.new'
-        StreamChat::ReviewQueueItemNewEvent
+        GetStream::Generated::Models::ReviewQueueItemNewEvent
       when 'review_queue_item.updated'
-        StreamChat::ReviewQueueItemUpdatedEvent
+        GetStream::Generated::Models::ReviewQueueItemUpdatedEvent
       when 'thread.updated'
-        StreamChat::ThreadUpdatedEvent
+        GetStream::Generated::Models::ThreadUpdatedEvent
       when 'user.banned'
-        StreamChat::UserBannedEvent
+        GetStream::Generated::Models::UserBannedEvent
       when 'user.deactivated'
-        StreamChat::UserDeactivatedEvent
+        GetStream::Generated::Models::UserDeactivatedEvent
       when 'user.deleted'
-        StreamChat::UserDeletedEvent
+        GetStream::Generated::Models::UserDeletedEvent
       when 'user.flagged'
-        StreamChat::UserFlaggedEvent
+        GetStream::Generated::Models::UserFlaggedEvent
       when 'user.messages.deleted'
-        StreamChat::UserMessagesDeletedEvent
+        GetStream::Generated::Models::UserMessagesDeletedEvent
       when 'user.muted'
-        StreamChat::UserMutedEvent
+        GetStream::Generated::Models::UserMutedEvent
       when 'user.reactivated'
-        StreamChat::UserReactivatedEvent
+        GetStream::Generated::Models::UserReactivatedEvent
       when 'user.unbanned'
-        StreamChat::UserUnbannedEvent
+        GetStream::Generated::Models::UserUnbannedEvent
       when 'user.unmuted'
-        StreamChat::UserUnmutedEvent
+        GetStream::Generated::Models::UserUnmutedEvent
       when 'user.unread_message_reminder'
-        StreamChat::UserUnreadReminderEvent
+        GetStream::Generated::Models::UserUnreadReminderEvent
       when 'user.updated'
-        StreamChat::UserUpdatedEvent
+        GetStream::Generated::Models::UserUpdatedEvent
       when 'user_group.created'
-        StreamChat::UserGroupCreatedEvent
+        GetStream::Generated::Models::UserGroupCreatedEvent
       when 'user_group.deleted'
-        StreamChat::UserGroupDeletedEvent
+        GetStream::Generated::Models::UserGroupDeletedEvent
       when 'user_group.member_added'
-        StreamChat::UserGroupMemberAddedEvent
+        GetStream::Generated::Models::UserGroupMemberAddedEvent
       when 'user_group.member_removed'
-        StreamChat::UserGroupMemberRemovedEvent
+        GetStream::Generated::Models::UserGroupMemberRemovedEvent
       when 'user_group.updated'
-        StreamChat::UserGroupUpdatedEvent
+        GetStream::Generated::Models::UserGroupUpdatedEvent
       else
         nil
       end
@@ -725,17 +772,201 @@ module StreamChat
 
     # Verify the HMAC-SHA256 signature of a webhook payload.
     #
-    # @param body [String] The raw request body
+    # @param body [String] The raw request body (already-decompressed)
     # @param signature [String] The signature from the X-Signature header
     # @param secret [String] Your webhook secret (found in the Stream Dashboard)
     # @return [Boolean] true if the signature is valid, false otherwise
     def self.verify_signature(body, signature, secret)
       return false if signature.nil? || signature.bytesize != 64
-      
+
       expected = OpenSSL::HMAC.hexdigest('SHA256', secret, body)
       OpenSSL.fixed_length_secure_compare(signature, expected)
     rescue ArgumentError
       false
     end
+
+    # Decompress the body if it is gzip-prefixed (first two bytes 0x1F 0x8B),
+    # else return the body bytes unchanged.
+    #
+    # Magic-byte detection is reliable for Stream payloads because Stream webhook
+    # bodies are always JSON, and JSON cannot start with 0x1F.
+    #
+    # @param body [String] raw body (binary-safe)
+    # @return [String] decompressed body, or the original body if not gzip-prefixed
+    # @raise [InvalidWebhookError] if body has the gzip magic prefix but
+    #        isn't a valid gzip stream
+    def self.gunzip_payload(body)
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: body must be a String" unless body.is_a?(String)
+
+      bytes = body.b
+      return bytes if bytes.bytesize < 2 || bytes.byteslice(0, 2) != GZIP_MAGIC
+
+      Zlib.gunzip(bytes)
+    rescue Zlib::Error => e
+      raise InvalidWebhookError, "#{InvalidWebhookError::GZIP_FAILED}: #{e.message}"
+    end
+
+    # Decode an SQS Message Body: try base64 first, fall back to raw bytes if
+    # base64 fails, then gunzip if gzip-prefixed.
+    #
+    # Wire format (per CHA-3071): SQS bodies are raw JSON when
+    # enable_hook_payload_compression is off (today's default for all existing
+    # apps), and base64(gzip(json)) when it's on. This helper handles both:
+    # raw JSON starts with '{' which is not valid base64, so the base64 decode
+    # fails and we fall through to raw bytes, then {gunzip_payload}'s magic-byte
+    # detection decides whether to decompress.
+    #
+    # {parse_sqs} sits on top of this and works transparently for both wire
+    # formats — no caller code change, no flag, no header.
+    #
+    # @param message_body [String]
+    # @return [String]
+    # @raise [InvalidWebhookError] only if gzip decompression fails (input had gzip magic prefix)
+    def self.decode_sqs_payload(message_body)
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: message_body must be a String" unless message_body.is_a?(String)
+
+      decoded =
+        begin
+          Base64.strict_decode64(message_body)
+        rescue ArgumentError
+          # Not base64 — treat input as raw bytes (uncompressed wire format).
+          message_body.dup.force_encoding(Encoding::ASCII_8BIT)
+        end
+      gunzip_payload(decoded)
+    end
+
+    # Return the inner +Message+ field when +body+ is a standard SNS
+    # notification envelope JSON; otherwise return +body+ unchanged so a
+    # pre-extracted Message string flows through.
+    #
+    # Heuristic: try to JSON-parse the input. If it yields a Hash with a
+    # String +Message+ field, that's the envelope shape — return the Message.
+    # Otherwise the input is presumed to BE the pre-extracted Message
+    # (base64-encoded bytes are not valid JSON, so this falls through cleanly).
+    def self.unwrap_sns_notification_body(body)
+      env = JSON.parse(body)
+      return env['Message'] if env.is_a?(Hash) && env['Message'].is_a?(String)
+
+      body
+    rescue JSON::ParserError
+      body
+    end
+    private_class_method :unwrap_sns_notification_body
+
+    # Decode an SNS notification body. Accepts either:
+    # * a full SNS HTTP notification envelope JSON
+    #   ({"Type":"Notification","Message":"<base64>",...}), or
+    # * a pre-extracted Message string (forwarded-through-SQS path).
+    # The inner payload is then base64-decoded and gunzipped via
+    # {decode_sqs_payload}.
+    #
+    # @param notification_body [String]
+    # @return [String]
+    # @raise [InvalidWebhookError]
+    def self.decode_sns_payload(notification_body)
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: notification_body must be a String" unless notification_body.is_a?(String)
+
+      decode_sqs_payload(unwrap_sns_notification_body(notification_body))
+    end
+
+    # Parse a webhook payload and return the typed event for known discriminators
+    # or {UnknownEvent} for well-formed-but-unknown ones.
+    #
+    # Distinct from {parse_webhook_event}: parse_event returns an UnknownEvent on
+    # unrecognized discriminators (forward-compat); parse_webhook_event throws.
+    #
+    # @param payload [String]
+    # @return [Object] the typed event class instance or {UnknownEvent}
+    # @raise [InvalidWebhookError] for invalid JSON, missing/non-string type field,
+    #        or known-type deserialization failure
+    def self.parse_event(payload)
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: payload must be a String" unless payload.is_a?(String)
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: payload must not be empty" if payload.empty?
+
+      data = JSON.parse(payload)
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: webhook payload must be a JSON object" unless data.is_a?(Hash)
+
+      event_type = data['type']
+      unless event_type.is_a?(String) && !event_type.empty?
+        raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: webhook payload missing 'type' string field"
+      end
+
+      event_class = event_class_for_type(event_type)
+      return build_unknown_event(event_type, data) if event_class.nil?
+
+      begin
+        event_class.new(data)
+      rescue StandardError => e
+        raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: failed to deserialize event: #{e.message}"
+      end
+    rescue JSON::ParserError => e
+      raise InvalidWebhookError, "#{InvalidWebhookError::INVALID_JSON}: failed to parse webhook payload: #{e.message}"
+    end
+
+    private_class_method def self.build_unknown_event(event_type, data)
+      created_raw = data['created_at']
+      created_at = nil
+      if created_raw.is_a?(String)
+        begin
+          created_at = Time.iso8601(created_raw)
+        rescue ArgumentError
+          created_at = nil
+        end
+      end
+      UnknownEvent.new(type: event_type, created_at: created_at, raw: data)
+    end
+
+    public
+
+    # HTTP composite: gunzip (if gzip-prefixed) -> verify HMAC-SHA256 -> parse.
+    #
+    # The signature header is X-Signature. The signature is HMAC-SHA256 of the
+    # *uncompressed* JSON body, hex-encoded. Magic-byte detection means callers
+    # can pass either the raw HTTP body or already-decompressed bytes; both work.
+    #
+    # @param body [String] raw request body (possibly gzip-compressed)
+    # @param signature [String] X-Signature header value
+    # @param secret [String] webhook secret
+    # @return [Object] the typed event class instance or {UnknownEvent}
+    # @raise [InvalidWebhookError] for every failure mode: signature mismatch,
+    #        gunzip failure, JSON parse, type dispatch, or event deserialization
+    #        failure. Filter on the message text (or the failure-mode constants
+    #        on InvalidWebhookError) to differentiate.
+    def self.verify_and_parse_webhook(body, signature, secret)
+      payload = gunzip_payload(body)
+      raise InvalidWebhookError, InvalidWebhookError::SIGNATURE_MISMATCH unless verify_signature(payload, signature, secret)
+
+      parse_event(payload)
+    end
+
+    # SQS composite: base64-decode -> gunzip (if gzip-prefixed) -> parse.
+    #
+    # The backend emits no signature attribute on SQS messages today; this helper
+    # therefore performs no signature verification. If a signed variant is added
+    # later, it will be a separate function rather than retrofitting this signature.
+    #
+    # @param message_body [String]
+    # @return [Object] the typed event class instance or {UnknownEvent}
+    # @raise [InvalidWebhookError]
+    def self.parse_sqs(message_body)
+      parse_event(decode_sqs_payload(message_body))
+    end
+
+    # SNS composite: parse SNS envelope -> base64-decode -> gunzip -> parse.
+    # Same no-signature posture as {parse_sqs}.
+    #
+    # @param notification_body [String]
+    # @return [Object] the typed event class instance or {UnknownEvent}
+    # @raise [InvalidWebhookError]
+    def self.parse_sns(notification_body)
+      parse_event(decode_sns_payload(notification_body))
+    end
   end
 end
+
+# Spec §7 alias: canonical name +Stream::Webhook+ aliases the existing
+# +StreamChat::Webhook+ for one minor-version cycle. New callers should use
+# the canonical name; existing callers continue to work unchanged.
+module Stream
+  Webhook = StreamChat::Webhook
+end

data/lib/getstream_ruby/version.rb

@@ -2,6 +2,6 @@
 
 module GetStreamRuby
 
-  VERSION = '6.1.1'
+  VERSION = '7.0.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: getstream-ruby
 version: !ruby/object:Gem::Version
-  version: 6.1.1
+  version: 7.0.0
 platform: ruby
 authors:
 - GetStream
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-11 00:00:00.000000000 Z
+date: 2026-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -1112,6 +1112,7 @@ files:
 - lib/getstream_ruby/generated/models/search_response.rb
 - lib/getstream_ruby/generated/models/search_result.rb
 - lib/getstream_ruby/generated/models/search_result_message.rb
+- lib/getstream_ruby/generated/models/search_roles_response.rb
 - lib/getstream_ruby/generated/models/search_user_groups_response.rb
 - lib/getstream_ruby/generated/models/search_warning.rb
 - lib/getstream_ruby/generated/models/segment.rb