blueticks 1.1.2 → 2.1.1

data/lib/blueticks/resources/scheduled_messages.rb

@@ -1,52 +1,101 @@
 # frozen_string_literal: true
 
 require_relative "../base_resource"
-require_relative "../types/deleted_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.
+      #
+      # `mentions` is an Array of participant JIDs to @mention in a group;
+      # `recipient_name` is an optional display name for the scheduled-message list.
+      #
+      # - `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,
+                 mentions: nil, recipient_name: 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?
+        body["mentions"] = mentions unless mentions.nil?
+        body["recipientName"] = recipient_name unless recipient_name.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, mentions: 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?
+        body["mentions"] = mentions unless mentions.nil?
+        env = client.request("PATCH", "/v1/scheduled-messages/#{message_id}", body: body)
+        Types::ScheduledMessage.from_hash(env && env["data"])
       end
 
-      # Cancel scheduled message.
-      #
-      # Cancel a queued scheduled message before it fires. Soft-deletes the row
-      # (still queryable in audit logs). Returns the deleted ref.
-      def delete(id)
-        data = client.request("DELETE", "/v1/scheduled-messages/#{id}")
-        Types::DeletedResource.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,57 @@
+# 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 `style`; `lyrics` is required unless `instrumental` is true. 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(style:, lyrics: nil, 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 = { "style" => style }
+        body["lyrics"] = lyrics unless lyrics.nil?
+        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

@@ -3,50 +3,50 @@
 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)
-        data = client.request("DELETE", "/v1/webhooks/#{webhook_id}")
-        Types::DeletedResource.from_hash(data)
-      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

data/lib/blueticks/types/audiences.rb

@@ -4,26 +4,32 @@ require_relative "base"
 
 module Blueticks
   module Types
-    class Contact < Base
+    # A contact stored inside an audience (ContactResponse). `variables` is a
+    # free-form hash of merge-field values.
+    class AudienceContact < Base
       field :id, :string
       field :to, :string
-      field :variables, %i[hash_of string]
-      field :added_at, :string
+      field :variables, :hash
+      field :added_at, :string, wire_name: "addedAt"
     end
 
+    # An audience (AudienceResponse).
     class Audience < Base
       field :id, :string
       field :name, :string
-      field :contact_count, :integer
-      field :created_at, :string
-      field :contacts, [:array, Contact], optional: true
-      field :page, :integer, optional: true
-      field :has_more, :boolean, optional: true
+      field :contact_count, :integer, wire_name: "contactCount"
+      field :created_at, :string, wire_name: "createdAt"
     end
 
+    # Result of appending contacts to an audience (POST .../contacts).
     class AppendContactsResult < Base
       field :added, :integer
-      field :contact_count, :integer
+      field :contact_count, :integer, wire_name: "contactCount"
+    end
+
+    # Result of removing a contact from an audience (DELETE .../contacts/{id}).
+    class ContactRemoval < Base
+      field :id, :string
     end
   end
 end

data/lib/blueticks/types/boards.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Blueticks
+  module Types
+    # A status/priority label with its colour (OptionRef).
+    class BoardOption < Base
+      field :label, :string
+      field :bgcolor, :string
+    end
+
+    # A board column definition (BoardColumn). `type` is the column kind
+    # (e.g. "status", "text"); `options` lists the selectable labels.
+    class BoardColumn < Base
+      field :column_id, :string
+      field :title, :string
+      field :type, :string
+      field :options, [:array, BoardOption]
+    end
+
+    # A board summary (BoardRow) as returned by boards.list.
+    class Board < Base
+      field :board_id, :string
+      field :name, :string
+      field :description, :string, optional: true
+      field :domain, :string, optional: true
+      field :agent_managed, :boolean
+      field :memory_retention_days, :integer, optional: true
+      field :item_count, :integer, optional: true
+      field :web_url, :string
+      field :created_at, :string
+      field :updated_at, :string
+    end
+
+    # A board with its columns (BoardDetail) as returned by boards.create and
+    # boards.retrieve.
+    class BoardDetail < Base
+      field :board_id, :string
+      field :name, :string
+      field :description, :string, optional: true
+      field :domain, :string, optional: true
+      field :agent_managed, :boolean
+      field :memory_retention_days, :integer, optional: true
+      field :item_count, :integer, optional: true
+      field :web_url, :string
+      field :created_at, :string
+      field :updated_at, :string
+      field :columns, [:array, BoardColumn]
+    end
+
+    # Short board reference (BoardRef) embedded in a bulk-upsert result.
+    class BoardRef < Base
+      field :board_id, :string
+      field :name, :string
+      field :description, :string, optional: true
+      field :domain, :string, optional: true
+      field :web_url, :string
+    end
+
+    # The chat message an item was extracted from (ItemSource).
+    class ItemSource < Base
+      field :chat_id, :string, optional: true
+      field :chat_name, :string, optional: true
+      field :message_key, :string, optional: true
+      field :excerpt, :string, optional: true
+      field :extracted_at, :integer, optional: true
+    end
+
+    # A board item / task (BoardItem). `cells` holds custom column values keyed
+    # by column title (string or number).
+    class BoardItem < Base
+      field :item_id, :string
+      field :text, :string
+      field :status, BoardOption, optional: true
+      field :priority, BoardOption, optional: true
+      field :due_date, :string, optional: true
+      field :cells, :hash, optional: true
+      field :source, ItemSource, optional: true
+      field :confidence, :number, optional: true
+      field :last_seen_at, :integer, optional: true
+      field :web_url, :string
+      field :created_at, :string
+      field :updated_at, :string
+    end
+
+    # Result of a bulk upsert (BulkItemsResponse).
+    class BulkItemsResult < Base
+      field :created, [:array, BoardItem]
+      field :updated, [:array, BoardItem]
+      field :unchanged, :integer
+      field :board, BoardRef
+    end
+
+    # One candidate-to-existing-item match (FindSimilarResponse.matches[]).
+    class SimilarMatch < Base
+      field :candidate_index, :integer
+      field :item_id, :string
+      field :text, :string
+      field :score, :number
+    end
+
+    # Result of boards.find_similar_items (FindSimilarResponse). `misses` holds
+    # the indexes of candidates with no match.
+    class FindSimilarResult < Base
+      field :matches, [:array, SimilarMatch]
+      field :misses, %i[array integer]
+    end
+  end
+end

data/lib/blueticks/types/campaigns.rb

@@ -8,21 +8,22 @@ module Blueticks
       pending running paused complete_sent complete_delivered aborted
     ].freeze
 
+    # A campaign (CampaignResponse). Note the id is carried on `cmp_id`
+    # (wire `cmpId`), matching the backend document shape.
     class Campaign < Base
-      field :id, :string
+      field :cmp_id, :string, wire_name: "cmpId"
       field :name, :string
-      field :audience_id, :string
+      field :audience_id, :string, wire_name: "audienceId"
       field :status, [:enum, CAMPAIGN_STATUSES]
-      field :total_count, :integer
-      field :sent_count, :integer
-      field :delivered_count, :integer
-      field :read_count, :integer
-      field :failed_count, :integer
-      field :from, :string, nullable: true
-      field :created_at, :string
-      field :started_at, :string, nullable: true
-      field :completed_at, :string, nullable: true
-      field :aborted_at, :string, nullable: true
+      field :total_count, :integer, wire_name: "totalCount"
+      field :sent_count, :integer, wire_name: "sentCount"
+      field :delivered_count, :integer, wire_name: "deliveredCount"
+      field :read_count, :integer, wire_name: "readCount"
+      field :failed_count, :integer, wire_name: "failedCount"
+      field :created_at, :string, wire_name: "createdAt"
+      field :started_at, :string, nullable: true, wire_name: "startedAt"
+      field :completed_at, :string, nullable: true, wire_name: "completedAt"
+      field :aborted_at, :string, nullable: true, wire_name: "abortedAt"
     end
   end
 end

data/lib/blueticks/types/chats.rb

@@ -4,88 +4,29 @@ require_relative "base"
 
 module Blueticks
   module Types
-    MESSAGE_TYPES = %w[
-      chat image video document audio ptt sticker gif ptv
-      poll_creation location vcard revoked
-    ].freeze
-
-    MEDIA_UNAVAILABLE_REASONS = %w[expired fetching awaiting_sender error no_media].freeze
+    CHAT_TYPES = %w[contact group newsletter].freeze
 
+    # A chat row (Chat) returned by chats.list / chats.retrieve.
     class Chat < Base
-      field :id, :string
-      field :name, :string, nullable: true
-      field :is_group, :boolean
-      field :last_message_at, :string, nullable: true
-      field :unread_count, :integer, nullable: true
-    end
-
+      field :chat_id, :string, wire_name: "chatId"
+      field :name, :string, nullable: true, optional: true
+      field :chat_type, [:enum, CHAT_TYPES], wire_name: "chatType"
+      field :pinned, :boolean, optional: true
+      field :archived, :boolean, optional: true
+      field :last_message_at, :string, nullable: true, optional: true, wire_name: "lastMessageAt"
+      field :unread_count, :integer, nullable: true, optional: true, wire_name: "unreadCount"
+      field :marked_unread, :boolean, wire_name: "markedUnread"
+      field :last_message_text, :string, nullable: true, optional: true, wire_name: "lastMessageText"
+      field :last_message_from_me, :boolean, nullable: true, optional: true, wire_name: "lastMessageFromMe"
+    end
+
+    # A participant of a group/community chat (Participant) as returned by
+    # chats.list_participants.
     class Participant < Base
-      field :chat_id, :string
-      field :is_admin, :boolean
-      field :is_super_admin, :boolean, nullable: true
-    end
-
-    class ChatMessage < Base
-      field :key, :string
-      field :chat_id, :string
-      field :from, :string
-      field :timestamp, :string, nullable: true
-      field :text, :string, nullable: true
-      field :type, :string
-      field :from_me, :boolean
-      field :ack, :integer, nullable: true
-      field :media_url, :string, nullable: true
-      field :caption, :string, nullable: true
-      field :filename, :string, nullable: true
-    end
-
-    class ChatMedia < Base
-      field :url, :string, nullable: true
-      field :mimetype, :string, nullable: true
-      field :filename, :string, nullable: true
-      field :data_base64, :string, nullable: true
-      field :original_quality, :boolean, nullable: true
-      field :media_unavailable, [:enum, MEDIA_UNAVAILABLE_REASONS], nullable: true
-    end
-
-    # Generic `{ "ok": true }` response envelope returned by acknowledged side-effects.
-    class OkResponse < Base
-      field :ok, :boolean
-    end
-
-    # `{ "chat_id": "..." }` envelope returned by /v1/chats/{chat_id}/open.
-    class ChatRef < Base
-      field :chat_id, :string
-    end
-
-    # `{ "ack": int|null }` envelope returned by .../messages/{key}/ack.
-    class MessageAck < Base
-      field :ack, :integer, nullable: true
-    end
-
-    # Response from POST /v1/chats/{chat_id}/messages/load_older.
-    class LoadOlderMessagesResponse < Base
-      field :total_messages, :integer, nullable: true
-      field :added, :integer, nullable: true
-      field :can_load_more, :boolean
-    end
-
-    # Response from GET /v1/chats/{chat_id}/messages/{key}/media_url.
-    class MediaUrlResponse < Base
-      field :url, :string, nullable: true
-    end
-
-    # Single entry in the BatchMessageAcksResponse `data` array.
-    # `{ "key": "<message key>", "ack": <int|null> }`.
-    class BatchMessageAckEntry < Base
-      field :key, :string
-      field :ack, :integer, nullable: true
-    end
-
-    # Response from POST /v1/chats/message_acks.
-    # `{ "data": [BatchMessageAckEntry, ...] }`.
-    class BatchMessageAcksResponse < Base
-      field :data, [:array, BatchMessageAckEntry]
+      field :chat_id, :string, wire_name: "chatId"
+      field :name, :string, nullable: true, optional: true
+      field :is_admin, :boolean, wire_name: "isAdmin"
+      field :is_super_admin, :boolean, optional: true, wire_name: "isSuperAdmin"
     end
   end
 end

data/lib/blueticks/types/contacts.rb

@@ -4,14 +4,13 @@ require_relative "base"
 
 module Blueticks
   module Types
+    # A WhatsApp contact known to the connected engine (contacts.list item).
+    # Per the spec, only `chatId` is required; `name` and `isBusiness` are
+    # optional and absent from real engine responses.
     class WhatsAppContact < Base
-      field :chat_id, :string
-      field :name, :string, nullable: true
-      field :is_business, :boolean
-    end
-
-    class ProfilePicture < Base
-      field :url, :string, nullable: true
+      field :chat_id, :string, wire_name: "chatId"
+      field :name, :string, optional: true, nullable: true
+      field :is_business, :boolean, optional: true, nullable: true, wire_name: "isBusiness"
     end
   end
 end

data/lib/blueticks/types/coverage.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Blueticks
+  module Types
+    # How far back a chat is loaded (LoadCoverage). `oldest_loaded_iso` is the
+    # deterministic answer to "have I reached far enough back?".
+    class Coverage < Base
+      field :oldest_loaded_timestamp, :number, optional: true, wire_name: "oldestLoadedTimestamp"
+      field :oldest_loaded_iso, :string, optional: true, wire_name: "oldestLoadedIso"
+    end
+  end
+end