postproxy-sdk 1.12.0 → 1.14.0

data/lib/postproxy/client.rb

@@ -10,6 +10,11 @@ require_relative "resources/comments"
 require_relative "resources/profile_comments"
 require_relative "resources/chats"
 require_relative "resources/messages"
+require_relative "resources/placements"
+require_relative "resources/api_keys"
+require_relative "resources/google_business"
+require_relative "resources/whatsapp_templates"
+require_relative "resources/whatsapp"
 
 module PostProxy
   class Client
@@ -29,6 +34,11 @@ module PostProxy
       @profile_comments = nil
       @chats = nil
       @messages = nil
+      @placements = nil
+      @api_keys = nil
+      @google_business = nil
+      @whatsapp_templates = nil
+      @whatsapp = nil
     end
 
     def posts
@@ -67,8 +77,30 @@ module PostProxy
       @messages ||= Resources::Messages.new(self)
     end
 
+    def placements
+      @placements ||= Resources::Placements.new(self)
+    end
+
+    def api_keys
+      @api_keys ||= Resources::ApiKeys.new(self)
+    end
+
+    def google_business
+      @google_business ||= Resources::GoogleBusiness.new(self)
+    end
+
+    def whatsapp_templates
+      @whatsapp_templates ||= Resources::WhatsAppTemplates.new(self)
+    end
+
+    def whatsapp
+      @whatsapp ||= Resources::WhatsApp.new(self)
+    end
+
+    # `raw: true` returns the body bytes and content type instead of parsing
+    # JSON (used for binary downloads).
     def request(method, path, params: nil, json: nil, data: nil, files: nil, profile_group_id: nil,
-      idempotency_key: nil)
+      idempotency_key: nil, headers: nil, raw: false)
       url = "/api#{path}"
 
       query = {}
@@ -92,18 +124,24 @@ module PostProxy
                        parts << [field, Faraday::Multipart::FilePart.new(io, content_type, filename)]
                      end
                    end
-                   # Build payload preserving duplicate keys
-                   payload = parts.each_with_object({}) do |(key, val), h|
-                     if h.key?(key)
-                       h[key] = [h[key]] unless h[key].is_a?(Array)
-                       h[key] << val
+                   # Build payload preserving duplicate keys. Repeated "foo[]"
+                   # parts are grouped under "foo" — Faraday appends "[]" to
+                   # each array item itself.
+                   grouped = parts.group_by(&:first)
+                   payload = grouped.each_with_object({}) do |(key, pairs), h|
+                     values = pairs.map(&:last)
+                     if values.size == 1
+                       h[key] = values.first
+                     elsif key.end_with?("[]")
+                       h[key.delete_suffix("[]")] = values
                      else
-                       h[key] = val
+                       h[key] = values
                      end
                    end
                    conn.send(method, url) do |req|
                      req.params = query unless query.empty?
                      req.headers["Idempotency-Key"] = idempotency_key if idempotency_key
+                     headers&.each { |k, v| req.headers[k] = v }
                      req.body = payload
                    end
                  else
@@ -111,10 +149,15 @@ module PostProxy
                    conn.send(method, url) do |req|
                      req.params = query unless query.empty?
                      req.headers["Idempotency-Key"] = idempotency_key if idempotency_key
+                     headers&.each { |k, v| req.headers[k] = v }
                      req.body = json.to_json if json
                    end
                  end
 
+      if raw && (200..299).cover?(response.status)
+        return RawResponse.new(data: response.body.to_s.b, content_type: response.headers["content-type"])
+      end
+
       handle_response(response)
     end
 
@@ -156,6 +199,21 @@ module PostProxy
           status_code: response.status,
           response: body
         )
+      when 403
+        body = parse_error_body(response)
+        raise ForbiddenError.new(
+          error_message(body),
+          status_code: response.status,
+          response: body
+        )
+      when 429
+        body = parse_error_body(response)
+        raise RateLimitError.new(
+          error_message(body),
+          status_code: response.status,
+          response: body,
+          retry_after: parse_retry_after(response.headers["retry-after"])
+        )
       when 404
         body = parse_error_body(response)
         raise NotFoundError.new(
@@ -200,6 +258,13 @@ module PostProxy
       { error: response.body }
     end
 
+    def parse_retry_after(value)
+      seconds = Float(value.to_s, exception: false)
+      return nil if seconds.nil? || !seconds.finite? || seconds <= 0
+
+      seconds == seconds.to_i ? seconds.to_i : seconds
+    end
+
     def error_message(body)
       body[:message] || body[:error]
     end

data/lib/postproxy/constants.rb

@@ -2,7 +2,7 @@ module PostProxy
   DEFAULT_BASE_URL = "https://api.postproxy.dev"
 
   PLATFORMS = %w[
-    facebook instagram tiktok linkedin youtube twitter threads pinterest bluesky telegram google_business
+    facebook instagram tiktok linkedin youtube twitter threads pinterest bluesky telegram google_business whatsapp
   ].freeze
 
   PROFILE_STATUSES = %w[active expired inactive].freeze
@@ -16,7 +16,7 @@ module PostProxy
   INSTAGRAM_FORMATS = %w[post reel story].freeze
   FACEBOOK_FORMATS = %w[post story reel].freeze
   TIKTOK_FORMATS = %w[video image].freeze
-  LINKEDIN_FORMATS = %w[post].freeze
+  LINKEDIN_FORMATS = %w[post poll].freeze
   YOUTUBE_FORMATS = %w[post].freeze
   PINTEREST_FORMATS = %w[pin].freeze
   THREADS_FORMATS = %w[post].freeze
@@ -32,6 +32,22 @@ module PostProxy
 
   TELEGRAM_PARSE_MODES = %w[HTML MarkdownV2].freeze
 
+  INSTAGRAM_TRIAL_STRATEGIES = %w[MANUAL SS_PERFORMANCE].freeze
+
+  INSTAGRAM_AUDIO_TYPES = %w[music original_sound].freeze
+
+  # Facebook and Instagram profiles connect through Facebook login; WhatsApp
+  # through the Cloud API or the WhatsApp Business app.
+  CONNECTION_ONBOARDINGS = %w[instagram facebook api business_app].freeze
+
+  DAILY_STATS_ATTRIBUTIONS = %w[received publish].freeze
+
+  PROFILE_INACTIVE_REASONS = %w[network_taken].freeze
+
+  POST_SYNC_TRIGGERS = %w[connect scheduled backfill].freeze
+
+  POST_SYNC_STATUSES = %w[pending running completed failed].freeze
+
   MESSAGE_DIRECTIONS = %w[inbound outbound].freeze
 
   MESSAGE_STATUSES = %w[pending published failed_waiting_for_retry failed received].freeze
@@ -42,13 +58,26 @@ module PostProxy
     platform_post.published
     platform_post.failed
     platform_post.failed_waiting_for_retry
+    platform_post.edited
+    platform_post.edit_failed
     platform_post.insights
     profile.connected
     profile.disconnected
     profile.stats
+    profile.placements_synced
+    placement.orphaned
+    placement.restored
     media.failed
     comment.created
+    comment.failed
+    comment.failed_waiting_for_retry
+    comment.delivery_unconfirmed
+    comment.edited
+    comment.edit_failed
     profile_comment.created
+    profile_comment.failed
+    profile_comment.failed_waiting_for_retry
+    profile_comment.deleted
     message.received
     message.sent
     message.delivered
@@ -58,5 +87,11 @@ module PostProxy
     message.failed_waiting_for_retry
     message.failed
     reaction.received
+    referral.received
+    message_template.status_updated
+    message_template.category_updated
+    placement.name_status_updated
+    placement.quality_updated
+    whatsapp.automatic_event
   ].freeze
 end

data/lib/postproxy/errors.rb

@@ -19,4 +19,19 @@ module PostProxy
 
   class ValidationError < Error; end
   class BadRequestError < Error; end
+
+  # 403. The account is canceled or past due, or the platform refused the
+  # action for lack of permission.
+  class ForbiddenError < Error; end
+
+  # 429. The posting rate limit was reached or the platform is rate-limiting.
+  # `retry_after` is the `Retry-After` header in seconds, or nil when absent.
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message, status_code: nil, response: nil, retry_after: nil)
+      super(message, status_code: status_code, response: response)
+      @retry_after = retry_after
+    end
+  end
 end

data/lib/postproxy/resources/api_keys.rb

@@ -0,0 +1,30 @@
+module PostProxy
+  module Resources
+    # Manage profile-group-scoped API keys. Requires an account-wide key.
+    class ApiKeys
+      def initialize(client)
+        @client = client
+      end
+
+      def list
+        result = @client.request(:get, "/api_keys")
+        keys = (result[:data] || []).map { |k| ApiKey.new(**k) }
+        ListResponse.new(data: keys)
+      end
+
+      # The returned `token` is shown only once.
+      def create(name, profile_group_id:, idempotency_key: nil)
+        result = @client.request(:post, "/api_keys",
+          json: { name: name, profile_group_id: profile_group_id },
+          idempotency_key: idempotency_key
+        )
+        ApiKey.new(**result)
+      end
+
+      def delete(id, idempotency_key: nil)
+        result = @client.request(:delete, "/api_keys/#{id}", idempotency_key: idempotency_key)
+        DeleteResponse.new(**result)
+      end
+    end
+  end
+end

data/lib/postproxy/resources/chats.rb

@@ -22,11 +22,14 @@ module PostProxy
         )
       end
 
+      # `placement_id` is required for WhatsApp: the phone number id from
+      # `profiles.placements`.
       def create(profile_id, participant_external_id, participant_username: nil, participant_name: nil,
-        profile_group_id: nil, idempotency_key: nil)
+        placement_id: nil, profile_group_id: nil, idempotency_key: nil)
         json_body = { participant_external_id: participant_external_id }
         json_body[:participant_username] = participant_username if participant_username
         json_body[:participant_name] = participant_name if participant_name
+        json_body[:placement_id] = placement_id if placement_id
 
         result = @client.request(:post, "/profiles/#{profile_id}/chats",
           json: json_body,
@@ -57,6 +60,32 @@ module PostProxy
         Chat.new(**result)
       end
 
+      # Mark the latest inbound message as read (shows the read receipt).
+      def mark_read(chat_id, profile_group_id: nil, idempotency_key: nil)
+        result = @client.request(:post, "/chats/#{chat_id}/mark_read",
+          profile_group_id: profile_group_id,
+          idempotency_key: idempotency_key
+        )
+        Chat.new(**result)
+      end
+
+      # Typing indicator. Facebook, Instagram and WhatsApp only.
+      def start_typing(chat_id, profile_group_id: nil, idempotency_key: nil)
+        result = @client.request(:post, "/chats/#{chat_id}/start_typing",
+          profile_group_id: profile_group_id,
+          idempotency_key: idempotency_key
+        )
+        AcceptedResponse.new(**result)
+      end
+
+      def stop_typing(chat_id, profile_group_id: nil, idempotency_key: nil)
+        result = @client.request(:post, "/chats/#{chat_id}/stop_typing",
+          profile_group_id: profile_group_id,
+          idempotency_key: idempotency_key
+        )
+        AcceptedResponse.new(**result)
+      end
+
       private
 
       def format_time(value)

data/lib/postproxy/resources/comments.rb

@@ -28,12 +28,13 @@ module PostProxy
       # Comments across every post in the profile group. Flat: replies come
       # back as their own entries linked by `parent_external_id`, so `total`
       # counts every comment. `profiles` takes profile IDs or network names,
-      # mixed.
-      def list_all(post_ids: nil, profiles: nil, from: nil, to: nil, page: nil, per_page: nil,
+      # mixed. `placement_id` narrows to one page / organization.
+      def list_all(post_ids: nil, profiles: nil, placement_id: nil, from: nil, to: nil, page: nil, per_page: nil,
         profile_group_id: nil)
         params = {}
         params[:post_ids] = Array(post_ids).join(",") if post_ids
         params[:profiles] = Array(profiles).join(",") if profiles
+        params[:placement_id] = placement_id if placement_id
         params[:from] = from if from
         params[:to] = to if to
         params[:page] = page if page
@@ -69,6 +70,18 @@ module PostProxy
         Comment.new(**result)
       end
 
+      # Edit a comment you published. Facebook and YouTube only. Runs in the
+      # background — the outcome arrives as `comment.edited` /
+      # `comment.edit_failed`.
+      def edit(post_id, comment_id, text, profile_id:, idempotency_key: nil)
+        result = @client.request(:patch, "/posts/#{post_id}/comments/#{comment_id}",
+          params: { profile_id: profile_id },
+          json: { body: text },
+          idempotency_key: idempotency_key
+        )
+        AcceptedResponse.new(**result)
+      end
+
       def delete(post_id, comment_id, profile_id:, idempotency_key: nil)
         result = @client.request(:delete, "/posts/#{post_id}/comments/#{comment_id}",
           params: { profile_id: profile_id },
@@ -109,14 +122,49 @@ module PostProxy
         AcceptedResponse.new(**result)
       end
 
-      def private_reply(post_id, comment_id, profile_id:, text:, idempotency_key: nil)
+      # TikTok only.
+      def pin(post_id, comment_id, profile_id:, idempotency_key: nil)
+        result = @client.request(:post, "/posts/#{post_id}/comments/#{comment_id}/pin",
+          params: { profile_id: profile_id },
+          idempotency_key: idempotency_key
+        )
+        AcceptedResponse.new(**result)
+      end
+
+      def unpin(post_id, comment_id, profile_id:, idempotency_key: nil)
+        result = @client.request(:post, "/posts/#{post_id}/comments/#{comment_id}/unpin",
+          params: { profile_id: profile_id },
+          idempotency_key: idempotency_key
+        )
+        AcceptedResponse.new(**result)
+      end
+
+      # Sends a DM to the comment's author (Instagram/Facebook) and returns a
+      # Message. One private reply per comment, within 7 days of it.
+      # `quick_replies`, `buttons`, `card` and `elements` work as in
+      # Messages#send_message (model instances or plain hashes); `text` may be
+      # empty when sending `elements`.
+      def private_reply(post_id, comment_id, profile_id:, text:, quick_replies: nil, buttons: nil, card: nil,
+        elements: nil, idempotency_key: nil)
+        json_body = { text: text }
+        json_body[:quick_replies] = quick_replies.map { |q| serialize_interactive(q) } if quick_replies
+        json_body[:buttons] = buttons.map { |b| serialize_interactive(b) } if buttons
+        json_body[:card] = serialize_interactive(card) if card
+        json_body[:elements] = elements.map { |e| serialize_interactive(e) } if elements
+
         result = @client.request(:post, "/posts/#{post_id}/comments/#{comment_id}/private_reply",
           params: { profile_id: profile_id },
-          json: { text: text },
+          json: json_body,
           idempotency_key: idempotency_key
         )
         Message.new(**result)
       end
+
+      private
+
+      def serialize_interactive(value)
+        value.respond_to?(:to_h) && !value.is_a?(Hash) ? value.to_h : value
+      end
     end
   end
 end

data/lib/postproxy/resources/google_business.rb

@@ -0,0 +1,194 @@
+module PostProxy
+  module Resources
+    # Manages a Google Business Profile location's own data — hours,
+    # attributes, services, menus, action links and photos — separate from
+    # posting to it.
+    #
+    # `location_id` is the placement id from `profiles.placements(profile_id)`.
+    # Google's payloads are camelCased and passed through untouched, so you can
+    # PATCH back exactly what you GET; responses are returned as plain hashes.
+    # Updates take a `fields` list naming which top-level fields to change
+    # (Google's update mask).
+    class GoogleBusiness
+      def initialize(client)
+        @client = client
+      end
+
+      # --- Location ---
+
+      def location(profile_id, location_id, read_mask: nil, profile_group_id: nil)
+        read(profile_id, "location", location_id, { read_mask: read_mask }, profile_group_id)
+      end
+
+      # `location` holds the Google fields to change (e.g. `title`,
+      # `phoneNumbers`, `websiteUri`); `fields` names them.
+      def update_location(profile_id, location_id, location, fields:, profile_group_id: nil, idempotency_key: nil)
+        write(:patch, profile_id, "update_location", location_id,
+          location.merge(fields: fields), profile_group_id, idempotency_key)
+      end
+
+      def available_location_categories(profile_id, location_id, region_code, language_code: nil, filter: nil,
+        view: nil, page_size: nil, page_token: nil, profile_group_id: nil)
+        read(profile_id, "available_location_categories", location_id, {
+          region_code: region_code,
+          language_code: language_code,
+          filter: filter,
+          view: view,
+          page_size: page_size,
+          page_token: page_token
+        }, profile_group_id)
+      end
+
+      def update_hours(profile_id, location_id, fields: nil, regular_hours: nil, special_hours: nil,
+        more_hours: nil, profile_group_id: nil, idempotency_key: nil)
+        write(:patch, profile_id, "update_hours", location_id, {
+          fields: fields,
+          regularHours: regular_hours,
+          specialHours: special_hours,
+          moreHours: more_hours
+        }, profile_group_id, idempotency_key)
+      end
+
+      # --- Attributes ---
+
+      def attributes(profile_id, location_id, profile_group_id: nil)
+        read(profile_id, "attributes", location_id, {}, profile_group_id)
+      end
+
+      def available_attributes(profile_id, location_id, category_name: nil, region_code: nil, language_code: nil,
+        show_all: nil, page_size: nil, page_token: nil, profile_group_id: nil)
+        read(profile_id, "available_attributes", location_id, {
+          category_name: category_name,
+          region_code: region_code,
+          language_code: language_code,
+          show_all: show_all,
+          page_size: page_size,
+          page_token: page_token
+        }, profile_group_id)
+      end
+
+      def update_attributes(profile_id, location_id, attributes, attribute_mask: nil, profile_group_id: nil,
+        idempotency_key: nil)
+        write(:patch, profile_id, "update_attributes", location_id,
+          { attributes: attributes, attribute_mask: attribute_mask }, profile_group_id, idempotency_key)
+      end
+
+      # --- Services & food menus ---
+
+      def service_list(profile_id, location_id, profile_group_id: nil)
+        read(profile_id, "service_list", location_id, {}, profile_group_id)
+      end
+
+      def update_service_list(profile_id, location_id, service_items, fields: nil, profile_group_id: nil,
+        idempotency_key: nil)
+        write(:patch, profile_id, "update_service_list", location_id,
+          { serviceItems: service_items, fields: fields }, profile_group_id, idempotency_key)
+      end
+
+      def food_menus(profile_id, location_id, fields: nil, profile_group_id: nil)
+        read(profile_id, "food_menus", location_id, { fields: fields && Array(fields).join(",") }, profile_group_id)
+      end
+
+      def update_food_menus(profile_id, location_id, menus, fields: nil, profile_group_id: nil,
+        idempotency_key: nil)
+        write(:patch, profile_id, "update_food_menus", location_id,
+          { menus: menus, fields: fields }, profile_group_id, idempotency_key)
+      end
+
+      # --- Place action links (booking, ordering, ...) ---
+
+      def place_action_links(profile_id, location_id, page_size: nil, page_token: nil, profile_group_id: nil)
+        read(profile_id, "place_action_links", location_id,
+          { page_size: page_size, page_token: page_token }, profile_group_id)
+      end
+
+      def available_place_action_types(profile_id, location_id, language_code: nil, page_size: nil,
+        page_token: nil, profile_group_id: nil)
+        read(profile_id, "available_place_action_types", location_id, {
+          language_code: language_code,
+          page_size: page_size,
+          page_token: page_token
+        }, profile_group_id)
+      end
+
+      # `place_action_type` is e.g. APPOINTMENT, ONLINE_APPOINTMENT,
+      # DINING_RESERVATION, FOOD_ORDERING, FOOD_DELIVERY, FOOD_TAKEOUT,
+      # SHOP_ONLINE.
+      def create_place_action_link(profile_id, location_id, uri:, place_action_type:, is_preferred: nil,
+        profile_group_id: nil, idempotency_key: nil)
+        write(:post, profile_id, "create_place_action_link", location_id, {
+          uri: uri,
+          place_action_type: place_action_type,
+          is_preferred: is_preferred
+        }, profile_group_id, idempotency_key)
+      end
+
+      # `name` is the link's resource name from #place_action_links.
+      def update_place_action_link(profile_id, location_id, name, fields:, uri: nil, place_action_type: nil,
+        is_preferred: nil, profile_group_id: nil, idempotency_key: nil)
+        write(:patch, profile_id, "update_place_action_link", location_id, {
+          name: name,
+          fields: fields,
+          uri: uri,
+          place_action_type: place_action_type,
+          is_preferred: is_preferred
+        }, profile_group_id, idempotency_key)
+      end
+
+      def delete_place_action_link(profile_id, location_id, name, profile_group_id: nil, idempotency_key: nil)
+        remove(profile_id, "delete_place_action_link", location_id, { name: name }, profile_group_id, idempotency_key)
+      end
+
+      # --- Media ---
+
+      def media(profile_id, location_id, page_size: nil, page_token: nil, profile_group_id: nil)
+        read(profile_id, "media", location_id, { page_size: page_size, page_token: page_token }, profile_group_id)
+      end
+
+      # `category` is e.g. COVER, PROFILE, LOGO, EXTERIOR, INTERIOR, PRODUCT,
+      # ADDITIONAL; `media_format` is PHOTO or VIDEO.
+      def create_media(profile_id, location_id, media_url, category: nil, media_format: nil, description: nil,
+        profile_group_id: nil, idempotency_key: nil)
+        write(:post, profile_id, "create_media", location_id, {
+          media_url: media_url,
+          category: category,
+          media_format: media_format,
+          description: description
+        }, profile_group_id, idempotency_key)
+      end
+
+      # `media_name` is the item's resource name from #media.
+      def delete_media(profile_id, location_id, media_name, profile_group_id: nil, idempotency_key: nil)
+        remove(profile_id, "delete_media", location_id, { media_name: media_name }, profile_group_id, idempotency_key)
+      end
+
+      private
+
+      def path(profile_id, action)
+        "/profiles/#{profile_id}/google_business/#{action}"
+      end
+
+      def read(profile_id, action, location_id, query, profile_group_id)
+        params = { location_id: location_id }.merge(query.compact)
+        @client.request(:get, path(profile_id, action), params: params, profile_group_id: profile_group_id)
+      end
+
+      def write(method, profile_id, action, location_id, body, profile_group_id, idempotency_key)
+        json_body = { location_id: location_id }.merge(body.compact)
+        @client.request(method, path(profile_id, action),
+          json: json_body,
+          profile_group_id: profile_group_id,
+          idempotency_key: idempotency_key
+        )
+      end
+
+      def remove(profile_id, action, location_id, query, profile_group_id, idempotency_key)
+        @client.request(:delete, path(profile_id, action),
+          params: { location_id: location_id }.merge(query),
+          profile_group_id: profile_group_id,
+          idempotency_key: idempotency_key
+        )
+      end
+    end
+  end
+end

data/lib/postproxy/resources/messages.rb

@@ -22,9 +22,28 @@ module PostProxy
         )
       end
 
+      # quick_replies, buttons, and card are Facebook and Instagram only — they
+      # return 422 on Telegram and Bluesky, where reply_markup is the
+      # equivalent. They are sent on the JSON path only, so pass media as hosted
+      # URLs rather than media_files when combining with an attachment.
+      #
+      # Each accepts model instances or plain hashes.
+      #
+      # `elements` sends a carousel of up to 10 cards (Facebook and Instagram);
+      # it can't be combined with body, buttons or card.
+      #
+      # WhatsApp: send exactly one of body, media, `template`, `interactive`,
+      # `location` or `contacts`. Outside the 24-hour window only a `template`
+      # gets through. `category: "utility"` sends a text message under the
+      # utility category; `link_preview` toggles URL previews, `voice_note`
+      # delivers an audio attachment as a voice note, and `filename` names a
+      # document attachment.
       def send_message(chat_id, body: nil, media: nil, media_files: nil, tag: nil,
-                       reply_to_external_id: nil, reply_markup: nil, profile_group_id: nil,
-                       idempotency_key: nil)
+                       reply_to_external_id: nil, reply_markup: nil,
+                       quick_replies: nil, buttons: nil, card: nil, elements: nil,
+                       template: nil, interactive: nil, location: nil, contacts: nil,
+                       category: nil, link_preview: nil, voice_note: nil, filename: nil,
+                       profile_group_id: nil, idempotency_key: nil)
         has_files = media_files && !media_files.empty?
 
         if has_files
@@ -32,6 +51,8 @@ module PostProxy
           form_data["body"] = body if body
           form_data["tag"] = tag if tag
           form_data["reply_to_external_id"] = reply_to_external_id if reply_to_external_id
+          form_data["voice_note"] = voice_note.to_s unless voice_note.nil?
+          form_data["filename"] = filename if filename
 
           files = []
           media&.each do |m|
@@ -58,6 +79,18 @@ module PostProxy
           json_body[:tag] = tag if tag
           json_body[:reply_to_external_id] = reply_to_external_id if reply_to_external_id
           json_body[:reply_markup] = reply_markup if reply_markup
+          json_body[:quick_replies] = quick_replies.map { |q| serialize_interactive(q) } if quick_replies
+          json_body[:buttons] = buttons.map { |b| serialize_interactive(b) } if buttons
+          json_body[:card] = serialize_interactive(card) if card
+          json_body[:elements] = elements.map { |e| serialize_interactive(e) } if elements
+          json_body[:template] = serialize_interactive(template) if template
+          json_body[:interactive] = interactive if interactive
+          json_body[:location] = serialize_interactive(location) if location
+          json_body[:contacts] = contacts if contacts
+          json_body[:category] = category if category
+          json_body[:link_preview] = link_preview unless link_preview.nil?
+          json_body[:voice_note] = voice_note unless voice_note.nil?
+          json_body[:filename] = filename if filename
 
           result = @client.request(:post, "/chats/#{chat_id}/messages",
             json: json_body,
@@ -111,6 +144,13 @@ module PostProxy
 
       private
 
+      # Interactive params accept model instances or plain hashes. Models expose
+      # to_h with nils dropped, so an omitted content_type stays omitted rather
+      # than being sent as null.
+      def serialize_interactive(value)
+        value.respond_to?(:to_h) && !value.is_a?(Hash) ? value.to_h : value
+      end
+
       def mime_type_for(filename)
         case File.extname(filename).downcase
         when ".jpg", ".jpeg" then "image/jpeg"
@@ -124,6 +164,7 @@ module PostProxy
         when ".mp3" then "audio/mpeg"
         when ".ogg" then "audio/ogg"
         when ".m4a" then "audio/mp4"
+        when ".pdf" then "application/pdf"
         else "application/octet-stream"
         end
       end