blueticks 1.1.1 → 2.0.0

data/lib/blueticks/resources/groups.rb

@@ -2,64 +2,90 @@
 
 require_relative "../base_resource"
 require_relative "../types/groups"
+require_relative "../types/paginated"
 
 module Blueticks
   module Resources
     class GroupsResource < BaseResource
+      # List groups.
+      #
+      # List the groups the connected WhatsApp engine sees. Offset-paginated
+      # (GroupListItem rows), with an optional case-insensitive name search via
+      # `search_token`.
+      def list(search_token: nil, include_archive: nil, skip: nil, limit: nil)
+        params = {}
+        params["searchToken"] = search_token unless search_token.nil?
+        params["includeArchive"] = include_archive unless include_archive.nil?
+        params["skip"] = skip unless skip.nil?
+        params["limit"] = limit unless limit.nil?
+        env = client.request("GET", "/v1/groups", params: params.empty? ? nil : params)
+        Types::PaginatedPage.from_hash(env, item_type: Types::GroupListItem)
+      end
+
       # Create a new group with an initial participant list.
       def create(name:, participants:)
-        data = client.request("POST", "/v1/groups",
-                              body: { "name" => name, "participants" => participants })
-        Types::Group.from_hash(data)
+        env = client.request("POST", "/v1/groups",
+                             body: { "name" => name, "participants" => participants })
+        Types::Group.from_hash(env && env["data"])
       end
 
-      # Retrieve group metadata by JID.
-      def get(group_id)
-        data = client.request("GET", "/v1/groups/#{group_id}")
-        Types::Group.from_hash(data)
+      # Retrieve group metadata by id. Pass `include: "participants"` to embed
+      # the participant list.
+      def retrieve(group_id, include: nil)
+        params = include.nil? ? nil : { "include" => include }
+        env = client.request("GET", "/v1/groups/#{group_id}", params: params)
+        Types::Group.from_hash(env && env["data"])
       end
 
-      # Rename the group and/or update admin-only settings.
+      # Rename the group and/or update admin-only settings. `settings` is a hash
+      # using the API's wire keys (announce, restrict, editInfoAdminsOnly,
+      # description).
       def update(group_id, name: nil, settings: nil)
         body = {}
         body["name"] = name unless name.nil?
         body["settings"] = settings unless settings.nil?
-        data = client.request("PATCH", "/v1/groups/#{group_id}", body: body)
-        Types::Group.from_hash(data)
+        env = client.request("PATCH", "/v1/groups/#{group_id}", body: body)
+        Types::Group.from_hash(env && env["data"])
       end
 
-      # Add a participant to the group by chat_id (JID) or +E.164 phone.
-      def add_member(group_id, chat_id:)
-        data = client.request("POST", "/v1/groups/#{group_id}/members",
-                              body: { "chat_id" => chat_id })
-        Types::Group.from_hash(data)
+      # Add members to the group by chat id (JID / +E.164) and/or a list of
+      # participants.
+      def add_members(group_id, chat_id: nil, participants: nil)
+        body = {}
+        body["chatId"] = chat_id unless chat_id.nil?
+        body["participants"] = participants unless participants.nil?
+        env = client.request("POST", "/v1/groups/#{group_id}/members", body: body)
+        Types::Group.from_hash(env && env["data"])
       end
 
       # Remove a participant from the group.
       def remove_member(group_id, chat_id)
-        data = client.request("DELETE", "/v1/groups/#{group_id}/members/#{chat_id}")
-        Types::Group.from_hash(data)
+        env = client.request("DELETE", "/v1/groups/#{group_id}/members/#{chat_id}")
+        Types::Group.from_hash(env && env["data"])
       end
 
       # Grant admin privileges to a group member.
       def promote_admin(group_id, chat_id)
-        data = client.request("POST", "/v1/groups/#{group_id}/members/#{chat_id}/admin")
-        Types::Group.from_hash(data)
+        env = client.request("POST", "/v1/groups/#{group_id}/members/#{chat_id}/admin")
+        Types::Group.from_hash(env && env["data"])
       end
 
       # Revoke admin privileges from a group member.
       def demote_admin(group_id, chat_id)
-        data = client.request("DELETE", "/v1/groups/#{group_id}/members/#{chat_id}/admin")
-        Types::Group.from_hash(data)
+        env = client.request("DELETE", "/v1/groups/#{group_id}/members/#{chat_id}/admin")
+        Types::Group.from_hash(env && env["data"])
       end
 
-      # Replace the group picture. `file_data_url` is a base64 data URL (PNG/JPEG, <=20 MiB).
-      def set_picture(group_id, file_data_url:, file_name: nil, file_mime_type: nil)
-        body = { "file_data_url" => file_data_url }
-        body["file_name"] = file_name unless file_name.nil?
-        body["file_mime_type"] = file_mime_type unless file_mime_type.nil?
-        data = client.request("PUT", "/v1/groups/#{group_id}/picture", body: body)
-        Types::Group.from_hash(data)
+      # Replace the group picture. `file_data_url` is a base64 data URL, or pass
+      # a hosted `url`.
+      def set_picture(group_id, file_data_url: nil, url: nil, file_name: nil, file_mime_type: nil)
+        body = {}
+        body["fileDataUrl"] = file_data_url unless file_data_url.nil?
+        body["url"] = url unless url.nil?
+        body["fileName"] = file_name unless file_name.nil?
+        body["fileMimeType"] = file_mime_type unless file_mime_type.nil?
+        env = client.request("PUT", "/v1/groups/#{group_id}/picture", body: body)
+        Types::Group.from_hash(env && env["data"])
       end
 
       # Leave the group as the authenticated identity. Idempotent (204).

data/lib/blueticks/resources/messages.rb

@@ -2,46 +2,125 @@
 
 require_relative "../base_resource"
 require_relative "../types/messages"
-require_relative "../types/page"
+require_relative "../types/ok_result"
+require_relative "../types/paginated"
 
 module Blueticks
   module Resources
     class MessagesResource < BaseResource
-      # Send a message immediately, or schedule one for later with `send_at:`.
-      #
-      # @param to [String] WhatsApp chat-id or phone number
-      # @param text [String, nil] Plain-text message body
-      # @param media_url [String, nil] Public URL to media to attach
-      # @param media_caption [String, nil] Caption for media
-      # @param send_at [String, nil] ISO 8601 timestamp to schedule
-      # @param from [String, nil] Multi-number engine identifier
-      # @param idempotency_key [String, nil] Optional idempotency key
-      # @return [Blueticks::Types::Message]
-      def send(to:, text: nil, media_url: nil, media_caption: nil, send_at: nil,
-               from: nil, idempotency_key: nil)
-        body = { "to" => to }
-        body["text"] = text unless text.nil?
-        body["media_url"] = media_url unless media_url.nil?
-        body["media_caption"] = media_caption unless media_caption.nil?
-        body["send_at"] = send_at unless send_at.nil?
-        body["from"] = from unless from.nil?
-        data = client.request("POST", "/v1/messages", body: body, idempotency_key: idempotency_key)
-        Types::Message.from_hash(data)
+      # Query messages from the WhatsApp store, newest first. Offset-paginated
+      # (PublicMessage rows). `message_types` is an Array of wire message types
+      # (e.g. `%w[chat image]`).
+      def list(chat_id: nil, search_token: nil, order: nil, since: nil, until_: nil,
+               message_types: nil, load_from_phone_if_needed: nil,
+               include_media_content: nil, skip: nil, limit: nil)
+        params = {}
+        params["chatId"] = chat_id unless chat_id.nil?
+        params["searchToken"] = search_token unless search_token.nil?
+        params["order"] = order unless order.nil?
+        params["since"] = since unless since.nil?
+        params["until"] = until_ unless until_.nil?
+        params["messageTypes"] = message_types.join(",") if message_types && !message_types.empty?
+        params["loadFromPhoneIfNeeded"] = load_from_phone_if_needed unless load_from_phone_if_needed.nil?
+        params["includeMediaContent"] = include_media_content unless include_media_content.nil?
+        params["skip"] = skip unless skip.nil?
+        params["limit"] = limit unless limit.nil?
+        env = client.request("GET", "/v1/messages", params: params.empty? ? nil : params)
+        Types::PaginatedPage.from_hash(env, item_type: Types::PublicMessage)
       end
 
-      # Retrieve a single message by id.
-      def get(message_id)
-        data = client.request("GET", "/v1/messages/#{message_id}")
-        Types::Message.from_hash(data)
+      # Retrieve a single store message by its serialized wire key. Pass
+      # `chat_id` to scope the lookup.
+      def retrieve(wa_message_key, chat_id: nil)
+        params = chat_id.nil? ? nil : { "chatId" => chat_id }
+        env = client.request("GET", "/v1/messages/#{wa_message_key}", params: params)
+        Types::PublicMessage.from_hash(env && env["data"])
       end
 
-      # List messages sent through the API, newest first. Cursor-paginated.
-      def list(limit: nil, cursor: nil)
+      # Get delivery acknowledgement for a single message.
+      def get_ack(wa_message_key, chat_id: nil)
+        params = chat_id.nil? ? nil : { "chatId" => chat_id }
+        env = client.request("GET", "/v1/messages/ack/#{wa_message_key}", params: params)
+        Types::MessageAck.from_hash(env && env["data"])
+      end
+
+      # Batch get delivery status for up to 200 sent messages. Offset-paginated
+      # (BatchAckEntry rows).
+      def batch_acks(message_keys:, chat_id: nil)
+        body = { "messageKeys" => message_keys }
+        body["chatId"] = chat_id unless chat_id.nil?
+        env = client.request("POST", "/v1/messages/acks", body: body)
+        Types::PaginatedPage.from_hash(env, item_type: Types::BatchAckEntry)
+      end
+
+      # Ask the engine to pull older history from the connected phone.
+      def load_older(chat_id)
+        env = client.request("POST", "/v1/messages/load_older/#{chat_id}")
+        Types::LoadOlderResult.from_hash(env && env["data"])
+      end
+
+      # Fetch media (URL and/or base64 bytes) for a message.
+      def get_media(wa_message_key, chat_id: nil, max_attempts: nil)
         params = {}
-        params["limit"] = limit unless limit.nil?
-        params["cursor"] = cursor unless cursor.nil?
-        data = client.request("GET", "/v1/messages", params: params.empty? ? nil : params)
-        Types::Page.from_hash(data, item_type: Types::Message)
+        params["chatId"] = chat_id unless chat_id.nil?
+        params["maxAttempts"] = max_attempts unless max_attempts.nil?
+        env = client.request("GET", "/v1/messages/media/#{wa_message_key}",
+                             params: params.empty? ? nil : params)
+        Types::Media.from_hash(env && env["data"])
+      end
+
+      # Pin a message. Optional `duration` (seconds) sets the pin TTL.
+      def pin(wa_message_key, chat_id: nil, duration: nil)
+        params = chat_id.nil? ? nil : { "chatId" => chat_id }
+        body = {}
+        body["duration"] = duration unless duration.nil?
+        env = client.request("POST", "/v1/messages/pin/#{wa_message_key}", params: params, body: body)
+        Types::OkResult.from_hash(env && env["data"])
+      end
+
+      # Unpin a message.
+      def unpin(wa_message_key, chat_id: nil)
+        params = chat_id.nil? ? nil : { "chatId" => chat_id }
+        env = client.request("POST", "/v1/messages/unpin/#{wa_message_key}", params: params)
+        Types::OkResult.from_hash(env && env["data"])
+      end
+
+      # List the pinned messages in a chat. Offset-paginated (PinnedMessage rows).
+      def pinned(chat_id)
+        env = client.request("GET", "/v1/messages/pinned/#{chat_id}")
+        Types::PaginatedPage.from_hash(env, item_type: Types::PinnedMessage)
+      end
+
+      # React to a message. Pass an empty `emoji` string to remove a reaction.
+      def react(wa_message_key, emoji:, chat_id: nil)
+        params = chat_id.nil? ? nil : { "chatId" => chat_id }
+        env = client.request("POST", "/v1/messages/reactions/#{wa_message_key}",
+                             params: params, body: { "emoji" => emoji })
+        Types::OkResult.from_hash(env && env["data"])
+      end
+
+      # Send a message immediately to a chat (direct dispatch — no queue row is
+      # persisted for the wait; the response carries the WhatsApp wire key). The
+      # body is a discriminated union keyed on `type` (`text`, `media`, `poll`).
+      def create(chat_id, type:, text: nil, media_url: nil, media_base64: nil,
+                 media_kind: nil, media_filename: nil, poll_question: nil,
+                 poll_options: nil, poll_allow_multiple: nil, reply_to: nil,
+                 secret: nil, with_typing: nil, typing_seconds: nil, idempotency_key: nil)
+        body = { "type" => type }
+        body["text"] = text unless text.nil?
+        body["mediaUrl"] = media_url unless media_url.nil?
+        body["mediaBase64"] = media_base64 unless media_base64.nil?
+        body["mediaKind"] = media_kind unless media_kind.nil?
+        body["mediaFilename"] = media_filename unless media_filename.nil?
+        body["pollQuestion"] = poll_question unless poll_question.nil?
+        body["pollOptions"] = poll_options unless poll_options.nil?
+        body["pollAllowMultiple"] = poll_allow_multiple unless poll_allow_multiple.nil?
+        body["replyTo"] = reply_to unless reply_to.nil?
+        body["secret"] = secret unless secret.nil?
+        body["withTyping"] = with_typing unless with_typing.nil?
+        body["typingSeconds"] = typing_seconds unless typing_seconds.nil?
+        env = client.request("POST", "/v1/messages/#{chat_id}", body: body, idempotency_key: idempotency_key)
+        Types::Message.from_hash(env && env["data"])
       end
     end
   end

data/lib/blueticks/resources/newsletters.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../base_resource"
+require_relative "../types/newsletter"
+require_relative "../types/paginated"
+
+module Blueticks
+  module Resources
+    class NewslettersResource < BaseResource
+      # List newsletters.
+      #
+      # List newsletters visible to the connected WhatsApp engine. Offset-paginated
+      # (NewsletterListItem rows). Requires `newsletters:read` scope.
+      def list(search_token: nil, include_archive: nil, skip: nil, limit: nil)
+        params = {}
+        params["searchToken"] = search_token unless search_token.nil?
+        params["includeArchive"] = include_archive unless include_archive.nil?
+        params["skip"] = skip unless skip.nil?
+        params["limit"] = limit unless limit.nil?
+        env = client.request("GET", "/v1/newsletters", params: params.empty? ? nil : params)
+        Types::PaginatedPage.from_hash(env, item_type: Types::NewsletterListItem)
+      end
+
+      # Create newsletter.
+      #
+      # Create a new WhatsApp newsletter (channel). Requires `messages:write` scope.
+      def create(name:, description: nil)
+        body = { "name" => name }
+        body["description"] = description unless description.nil?
+        env = client.request("POST", "/v1/newsletters", body: body)
+        Types::Newsletter.from_hash(env && env["data"])
+      end
+
+      # Get newsletter.
+      #
+      # Retrieve a newsletter by its JID. Requires `newsletters:read` scope.
+      def retrieve(newsletter_id)
+        env = client.request("GET", "/v1/newsletters/#{newsletter_id}")
+        Types::Newsletter.from_hash(env && env["data"])
+      end
+    end
+  end
+end

data/lib/blueticks/resources/ping.rb

@@ -6,10 +6,13 @@ require_relative "../types/ping"
 module Blueticks
   module Resources
     class PingResource < BaseResource
-      # Health check. Returns basic info about the authenticated API key.
+      # Ping.
+      #
+      # Probe the API: returns `api: "ok"`, the account id, and the currently
+      # connected WhatsApp engines. Useful as a connection/liveness test.
       def retrieve
-        data = client.request("GET", "/v1/ping")
-        Types::Ping.from_hash(data)
+        env = client.request("GET", "/v1/ping")
+        Types::Ping.from_hash(env && env["data"])
       end
     end
   end

data/lib/blueticks/resources/scheduled_messages.rb

@@ -2,49 +2,93 @@
 
 require_relative "../base_resource"
 require_relative "../types/scheduled_messages"
-require_relative "../types/page"
+require_relative "../types/deleted_resource"
+require_relative "../types/paginated"
 
 module Blueticks
   module Resources
     class ScheduledMessagesResource < BaseResource
-      # List scheduled messages.
+      # Send / schedule a message to a chat.
       #
-      # Retrieves a list of all resources from the service. Cursor-paginated.
-      def list(limit: nil, cursor: nil)
-        params = {}
-        params["limit"] = limit unless limit.nil?
-        params["cursor"] = cursor unless cursor.nil?
-        data = client.request("GET", "/v1/scheduled-messages", params: params.empty? ? nil : params)
-        Types::Page.from_hash(data, item_type: Types::ScheduledMessage)
+      # Queue a message for delivery to `chat_id` (a WhatsApp JID or phone). The
+      # body is a discriminated union keyed on `type` (`text`, `media`, `poll`).
+      # Omit `send_at` to dispatch as soon as possible, or pass an ISO-8601
+      # timestamp to schedule it.
+      #
+      # - `type: "text"`  — requires `text`.
+      # - `type: "media"` — requires `media_url` or `media_base64`; optional
+      #   `media_kind`, `media_filename`.
+      # - `type: "poll"`  — requires `poll_question` and `poll_options`; optional
+      #   `poll_allow_multiple`.
+      def create(chat_id, type:, text: nil, media_url: nil, media_base64: nil,
+                 media_kind: nil, media_filename: nil, poll_question: nil,
+                 poll_options: nil, poll_allow_multiple: nil, reply_to: nil,
+                 secret: nil, send_at: nil, idempotency_key: nil)
+        body = { "type" => type }
+        body["text"] = text unless text.nil?
+        body["mediaUrl"] = media_url unless media_url.nil?
+        body["mediaBase64"] = media_base64 unless media_base64.nil?
+        body["mediaKind"] = media_kind unless media_kind.nil?
+        body["mediaFilename"] = media_filename unless media_filename.nil?
+        body["pollQuestion"] = poll_question unless poll_question.nil?
+        body["pollOptions"] = poll_options unless poll_options.nil?
+        body["pollAllowMultiple"] = poll_allow_multiple unless poll_allow_multiple.nil?
+        body["replyTo"] = reply_to unless reply_to.nil?
+        body["secret"] = secret unless secret.nil?
+        body["sendAt"] = send_at unless send_at.nil?
+        env = client.request("POST", "/v1/scheduled-messages/#{chat_id}", body: body,
+                                                                          idempotency_key: idempotency_key)
+        Types::ScheduledMessage.from_hash(env && env["data"])
       end
 
-      # Get scheduled message.
-      #
-      # Retrieves a single resource with the given id from the service.
-      def retrieve(id)
-        data = client.request("GET", "/v1/scheduled-messages/#{id}")
-        Types::ScheduledMessage.from_hash(data)
+      # Get the current status of a queued/scheduled message by id.
+      def retrieve(message_id)
+        env = client.request("GET", "/v1/scheduled-messages/#{message_id}")
+        Types::ScheduledMessage.from_hash(env && env["data"])
       end
 
-      # Update scheduled message.
-      #
-      # Updates the resource identified by id using data.
-      def update(id, text: nil, media_url: nil, media_caption: nil, send_at: nil)
+      # List messages in the user-messages queue (all sources), newest first.
+      # Offset-paginated. Optionally filter by `chat_id` and/or lifecycle
+      # `status`.
+      def list(chat_id: nil, search_token: nil, status: nil, order: nil, skip: nil, limit: nil)
+        params = {}
+        params["chatId"] = chat_id unless chat_id.nil?
+        params["searchToken"] = search_token unless search_token.nil?
+        params["status"] = status unless status.nil?
+        params["order"] = order unless order.nil?
+        params["skip"] = skip unless skip.nil?
+        params["limit"] = limit unless limit.nil?
+        env = client.request("GET", "/v1/scheduled-messages", params: params.empty? ? nil : params)
+        Types::PaginatedPage.from_hash(env, item_type: Types::ScheduledMessage)
+      end
+
+      # Edit a previously-queued message that has not dispatched yet. Pass any
+      # subset of the editable fields.
+      def update(message_id, type: nil, text: nil, media_url: nil, media_base64: nil,
+                 media_kind: nil, media_filename: nil, poll_question: nil,
+                 poll_options: nil, poll_allow_multiple: nil, reply_to: nil,
+                 secret: nil, send_at: nil)
         body = {}
+        body["type"] = type unless type.nil?
         body["text"] = text unless text.nil?
-        body["media_url"] = media_url unless media_url.nil?
-        body["media_caption"] = media_caption unless media_caption.nil?
-        body["send_at"] = send_at unless send_at.nil?
-        data = client.request("PATCH", "/v1/scheduled-messages/#{id}", body: body)
-        Types::ScheduledMessage.from_hash(data)
+        body["mediaUrl"] = media_url unless media_url.nil?
+        body["mediaBase64"] = media_base64 unless media_base64.nil?
+        body["mediaKind"] = media_kind unless media_kind.nil?
+        body["mediaFilename"] = media_filename unless media_filename.nil?
+        body["pollQuestion"] = poll_question unless poll_question.nil?
+        body["pollOptions"] = poll_options unless poll_options.nil?
+        body["pollAllowMultiple"] = poll_allow_multiple unless poll_allow_multiple.nil?
+        body["replyTo"] = reply_to unless reply_to.nil?
+        body["secret"] = secret unless secret.nil?
+        body["sendAt"] = send_at unless send_at.nil?
+        env = client.request("PATCH", "/v1/scheduled-messages/#{message_id}", body: body)
+        Types::ScheduledMessage.from_hash(env && env["data"])
       end
 
-      # Cancel scheduled message.
-      #
-      # Removes the resource with id.
-      def delete(id)
-        data = client.request("DELETE", "/v1/scheduled-messages/#{id}")
-        Types::ScheduledMessage.from_hash(data)
+      # Delete (cancel) a queued/scheduled message by id.
+      def delete(message_id)
+        env = client.request("DELETE", "/v1/scheduled-messages/#{message_id}")
+        Types::DeletedResource.from_hash(env && env["data"])
       end
     end
   end

data/lib/blueticks/resources/suno.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../base_resource"
+require_relative "../types/suno"
+
+module Blueticks
+  module Resources
+    class SunoResource < BaseResource
+      # Get the Suno credit / plan usage for the workspace.
+      def account
+        env = client.request("GET", "/v1/suno/account")
+        Types::SunoAccount.from_hash(env && env["data"])
+      end
+
+      # Submit a song generation job. Requires `lyrics` and `style`; the many
+      # optional knobs mirror the Suno request (vocal_gender, weirdness,
+      # style_influence, audio_influence, instrumental, model, title, upload_id,
+      # captcha_token, negative_style).
+      def create_song(lyrics:, style:, negative_style: nil, vocal_gender: nil,
+                      weirdness: nil, style_influence: nil, audio_influence: nil,
+                      instrumental: nil, model: nil, title: nil, upload_id: nil,
+                      captcha_token: nil)
+        body = { "lyrics" => lyrics, "style" => style }
+        body["negativeStyle"] = negative_style unless negative_style.nil?
+        body["vocalGender"] = vocal_gender unless vocal_gender.nil?
+        body["weirdness"] = weirdness unless weirdness.nil?
+        body["styleInfluence"] = style_influence unless style_influence.nil?
+        body["audioInfluence"] = audio_influence unless audio_influence.nil?
+        body["instrumental"] = instrumental unless instrumental.nil?
+        body["model"] = model unless model.nil?
+        body["title"] = title unless title.nil?
+        body["uploadId"] = upload_id unless upload_id.nil?
+        body["captchaToken"] = captcha_token unless captcha_token.nil?
+        env = client.request("POST", "/v1/suno/songs", body: body)
+        Types::GenerateSongResult.from_hash(env && env["data"])
+      end
+
+      # Get a generated song (clip) by id.
+      def get_song(song_id)
+        env = client.request("GET", "/v1/suno/songs/#{song_id}")
+        Types::SongClip.from_hash(env && env["data"])
+      end
+
+      # Register a reference-audio upload (by URL or base64) for use as an
+      # influence on a subsequent song generation.
+      def create_upload(audio_url: nil, audio_base64: nil, file_name: nil)
+        body = {}
+        body["audioUrl"] = audio_url unless audio_url.nil?
+        body["audioBase64"] = audio_base64 unless audio_base64.nil?
+        body["fileName"] = file_name unless file_name.nil?
+        env = client.request("POST", "/v1/suno/uploads", body: body)
+        Types::CreateUploadResult.from_hash(env && env["data"])
+      end
+    end
+  end
+end

data/lib/blueticks/resources/utils.rb

@@ -1,23 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "../base_resource"
-require_relative "../types/utils"
 
 module Blueticks
   module Resources
+    # UtilsResource had methods for /v1/utils/* which are not in the current spec.
+    # The accessor is kept for backward compatibility with test_client.rb.
+    # No public methods are exposed.
     class UtilsResource < BaseResource
-      # Validate a phone number or chat-id; returns the engine's canonical form.
-      def validate_phone(phone_or_chat_id:)
-        data = client.request("POST", "/v1/utils/validate_phone",
-                              body: { "phone_or_chat_id" => phone_or_chat_id })
-        Types::PhoneValidation.from_hash(data)
-      end
-
-      # Fetch OpenGraph-style metadata for a URL (uses the engine's renderer).
-      def link_preview(url:)
-        data = client.request("GET", "/v1/utils/link_preview", params: { "url" => url })
-        Types::LinkPreview.from_hash(data)
-      end
     end
   end
 end

data/lib/blueticks/resources/webhooks.rb

@@ -1,51 +1,52 @@
 # frozen_string_literal: true
 
 require_relative "../base_resource"
+require_relative "../types/deleted_resource"
 require_relative "../types/webhooks"
-require_relative "../types/page"
+require_relative "../types/paginated"
 
 module Blueticks
   module Resources
     class WebhooksResource < BaseResource
+      # Create a webhook subscription.
       def create(url:, events:, description: nil)
         body = { "url" => url, "events" => events }
         body["description"] = description unless description.nil?
-        data = client.request("POST", "/v1/webhooks", body: body)
-        Types::WebhookCreateResult.from_hash(data)
+        env = client.request("POST", "/v1/webhooks", body: body)
+        Types::Webhook.from_hash(env && env["data"])
       end
 
-      # List webhooks, newest first. Cursor-paginated.
-      def list(limit: nil, cursor: nil)
+      # List webhooks, newest first. Offset-paginated.
+      def list(order: nil, skip: nil, limit: nil)
         params = {}
+        params["order"] = order unless order.nil?
+        params["skip"] = skip unless skip.nil?
         params["limit"] = limit unless limit.nil?
-        params["cursor"] = cursor unless cursor.nil?
-        data = client.request("GET", "/v1/webhooks", params: params.empty? ? nil : params)
-        Types::Page.from_hash(data, item_type: Types::Webhook)
+        env = client.request("GET", "/v1/webhooks", params: params.empty? ? nil : params)
+        Types::PaginatedPage.from_hash(env, item_type: Types::Webhook)
       end
 
-      def get(webhook_id)
-        data = client.request("GET", "/v1/webhooks/#{webhook_id}")
-        Types::Webhook.from_hash(data)
+      # Retrieve a webhook by id.
+      def retrieve(webhook_id)
+        env = client.request("GET", "/v1/webhooks/#{webhook_id}")
+        Types::Webhook.from_hash(env && env["data"])
       end
 
+      # Update a webhook's url, events, description and/or status.
       def update(webhook_id, url: nil, events: nil, description: nil, status: nil)
         body = {}
         body["url"] = url unless url.nil?
         body["events"] = events unless events.nil?
         body["description"] = description unless description.nil?
         body["status"] = status unless status.nil?
-        data = client.request("PATCH", "/v1/webhooks/#{webhook_id}", body: body)
-        Types::Webhook.from_hash(data)
+        env = client.request("PATCH", "/v1/webhooks/#{webhook_id}", body: body)
+        Types::Webhook.from_hash(env && env["data"])
       end
 
+      # Delete a webhook.
       def delete(webhook_id)
-        client.request("DELETE", "/v1/webhooks/#{webhook_id}")
-        nil
-      end
-
-      def rotate_secret(webhook_id)
-        data = client.request("POST", "/v1/webhooks/#{webhook_id}/rotate-secret")
-        Types::WebhookCreateResult.from_hash(data)
+        env = client.request("DELETE", "/v1/webhooks/#{webhook_id}")
+        Types::DeletedResource.from_hash(env && env["data"])
       end
     end
   end

data/lib/blueticks/types/account.rb

@@ -8,8 +8,9 @@ module Blueticks
     class Account < Base
       field :id, :string
       field :name, :string
+      field :user_email, :string, nullable: true, wire_name: "userEmail"
       field :timezone, :string, nullable: true
-      field :created_at, :string
+      field :created_at, :string, wire_name: "createdAt"
     end
   end
 end