sentdm 0.45.0 → 0.47.0

data/rbi/sentdm/resources/sender_profiles.rbi

@@ -0,0 +1,463 @@
+# typed: strong
+
+module Sentdm
+  module Resources
+    # Your customers, each sending as itself.
+    #
+    # A sender profile is a tenant of yours: it has its own API key, its own balance,
+    # and can have its own identity and senders — so your customers send under their
+    # own brand and never see Sent. Depth is one; a profile cannot create profiles.
+    #
+    # **Everything is inherited unless the profile owns it.** `{ "name": "…" }` alone
+    # gives you a usable profile immediately, running on your identity, your inbox and
+    # your billing. Supply a capability's fields and the profile owns that one
+    # instead.
+    #
+    # **A sender is the exception.** A brand and a campaign can be inherited; a number
+    # cannot. A profile either has a sender of its own or reaches only the countries
+    # Sent runs a shared route for, and the US is not one of them.
+    #
+    # To act for a profile on any other resource, send `x-profile-id` with your
+    # organization key rather than looking for a parallel set of endpoints.
+    class SenderProfiles
+      # Creates a sender profile under your organization. A profile is a customer of
+      # yours: it sends under its own or your identity, and your customers never see
+      # Sent.
+      #
+      # ## The minimum
+      #
+      # `{ "name": "Example Retail", "short_name": "Example" }`. `short_name` is the SMS
+      # sender id and is required. Inbox and opt-out list come from your organization.
+      # Its brand and campaign are your organization's only where `compliance` says
+      # `{ "inherit": true }` — omitted, the profile has neither. Billing defaults to
+      # the profile's own balance, with your organization covering what it cannot.
+      #
+      # **A sender is not one of them.** The brand and the campaign can be inherited; a
+      # number cannot. A profile either has a sender of its own — `channels.sms` — or it
+      # has none and reaches only the countries Sent runs a shared route for. The US has
+      # none: without a `TEN_DLC` number of its own, a profile's SMS to US numbers ends
+      # as `FAILED` with `DELIVERY_003`.
+      #
+      # ## Saying what a profile owns
+      #
+      # Every capability is one of three things, and there is no flag per state:
+      #
+      # - **Its own** — supply the capability's fields. Data is what owning looks like.
+      # - **The organization's** — `{ "inherit": true }`, with nothing else.
+      # - **None** — omit the block.
+      #
+      # There is no `"inherit": false` that also carries no data. A second way to say
+      # the same thing would let a request contradict itself.
+      #
+      # Inheriting needs no id. A customer has exactly one brand, so `brand` resolves
+      # without one.
+      #
+      # **The campaign has no block of its own.** It is only ever a registration, and
+      # every field of one is something a specific market demands — so it lives in
+      # `compliance`, alongside the rest of what that market asks for, and it says whose
+      # it is there too: `"compliance": { "campaign": { "inherit": true } }` runs the
+      # profile on your organization's campaign and brand, and stops this call asking
+      # for any campaign field. `"brand": { "inherit": true }` alone inherits the brand
+      # only: the campaign is then the profile's own. Inheriting takes _all_ of your
+      # organization's, because inheritance resolves an owner rather than a single row.
+      #
+      # A profile with a `brand` of its own **cannot** inherit the campaign, and asking
+      # is refused with `400`: a campaign is filed against a brand registration, and
+      # your organization's campaign is filed against your organization's brand rather
+      # than this profile's. Inherit both, own both, or inherit the brand and own the
+      # campaign.
+      #
+      # `channels.sms` is the market the profile starts in — one `country` and
+      # `number_type`. It decides what else this call asks for: the compliance catalog
+      # is keyed on that pair, and it determines which fields `brand` accepts and what
+      # `compliance` answers for.
+      #
+      # **Several numbers in that market**: `channels.sms.numbers` lists them, one entry
+      # per area code, e.g. `[{"area_code": "212", "quantity": 2}, {"quantity": 1}]` for
+      # two in 212 and one in any area code. `quantity` defaults to 1, an entry without
+      # `area_code` means any area code, and the total is at most 49. The market is
+      # created with **one campaign**, the one in `compliance.campaign`, and a US
+      # `TEN_DLC` market's numbers are stored on it and assigned when it is approved. A
+      # profile inheriting your organization's campaign keeps one number. Every number
+      # is listed in `channels.sms[].numbers` with its area code and status.
+      #
+      # A profile is a tenant, not a market, so it can go on to send in several — but
+      # through `POST /v3/channels/sms` with the `x-profile-id` header, one market and
+      # its compliance at a time. Reads return every market as `channels.sms[]`, so the
+      # read shape is a list even where this one is not.
+      #
+      # `brand` is required when `number_type` is `TEN_DLC` — inherited or its own. A
+      # 10DLC registration has nothing to attach to without one, and no later call can
+      # supply it, so omitting it is refused with `400` rather than reported as
+      # outstanding.
+      #
+      # ## Use cases and volume
+      #
+      # A TCR campaign declares one to five `use_cases`, each with its own
+      # `sample_messages` — TCR attributes samples to the use case they illustrate, so
+      # they travel together.
+      #
+      # How that set registers is derived from `volume` and never declared. Below the
+      # low-volume threshold the campaign registers as `LOW_VOLUME` with every entry as
+      # a sub-use-case; above it, one entry registers as that use case outright and
+      # several register as `MIXED` with sub-use-cases. `MIXED` and `LOW_VOLUME` are
+      # therefore refused as `use_case` values: they describe the shape of a set, which
+      # is ours to work out.
+      #
+      # **Leaving `volume` out is accepted and costs more.** An absent value registers
+      # the campaign at the standard tier, which carries the higher fee — so say so when
+      # a campaign is low volume. Sole proprietor brands are the exception: their fee is
+      # fixed by entity type, and volume only decides the use case.
+      #
+      # ## Compliance
+      #
+      # `brand` is captured identically in every country. Everything a specific market
+      # demands on top of it — including every field of the campaign — goes in
+      # `compliance`, as key/value entries whose keys depend on the sender's country and
+      # type. US `TEN_DLC` registers with The Campaign Registry and asks for a
+      # substantial set; an alphanumeric sender may pre-register with documents, or need
+      # nothing at all.
+      #
+      # You do not have to know any of it. Omit `compliance` and the response lists
+      # exactly what is outstanding, with types and accepted values — or call
+      # `GET /v3/compliance/requirements` first. Anything Sent supplies on your behalf
+      # is never asked for, and is rejected if sent.
+      #
+      # Requirements can be conditional, and the condition is published as
+      # `required_when` so you can render a form from it rather than discover the rule
+      # by being rejected. Every US `TEN_DLC` campaign field carries
+      # `compliance.inherit != true` — send `"inherit": true` and none of them is asked
+      # for or accepted, because the profile is running on your organization's campaign.
+      #
+      # ## Uploading documents
+      #
+      # Send `application/json` for everything except a market that pre-registers a
+      # sender with supporting documents. For those, send `multipart/form-data` instead:
+      # put this entire document — unchanged — in a single field named `profile`, and
+      # attach each file under a field named after the compliance key it satisfies.
+      # Individual form fields per property are not read; the payload is always the one
+      # `profile` field.
+      #
+      # A pre-registration market has no `brand` and no `campaign` — those are asked for
+      # only where a regime registers one — so its `compliance` carries nothing at all,
+      # and the documents are the request:
+      #
+      # ```bash
+      # curl -X POST https://api.sent.dm/v3/sender-profiles \
+      #   -H 'x-api-key: YOUR_SECRET_TOKEN' \
+      #   -F 'profile={
+      #         "name": "Example Retail",
+      #         "short_name": "EXAMPLE",
+      #         "channels": {
+      #           "sms": {
+      #             "country": "XK",
+      #             "number_type": "ALPHANUMERIC",
+      #             "sender_value": "EXAMPLE"
+      #           }
+      #         }
+      #       }' \
+      #   -F 'business_registration=@registration.pdf' \
+      #   -F 'letter_of_authorization=@loa.pdf'
+      # ```
+      #
+      # `business_registration` and `letter_of_authorization` are illustrative. The real
+      # field names are whatever that market configures, so read them from
+      # `GET /v3/compliance/requirements`, which lists documents separately from the
+      # values — under `attachments`, each with the `field_name` to put the file under.
+      #
+      # A document has no JSON form, so naming one in `compliance` is refused with `400`
+      # rather than ignored: accepting it would report the requirement as satisfied
+      # while no file was ever stored.
+      #
+      # ## WhatsApp and RCS
+      #
+      # Neither can be inherited, so neither takes an `inherit`: the profile's WhatsApp
+      # account and RCS agent are its own or it has none. Sharing your organization's
+      # would share its inbox and its throughput, which makes the two indistinguishable
+      # to a recipient.
+      #
+      # `channels.whatsapp` names one of the accounts shared into your organization, and
+      # takes the two identifiers nothing else can supply: `waba_id`, because your
+      # organization holds one account per client, and `phone_number_id`, because naming
+      # the account's number is what assigns it to the profile as the number it sends
+      # from.
+      #
+      # Everything else is resolved from your organization — the Multi-Partner Solution
+      # the account arrived through, the client business portfolio that owns it, the
+      # access token and that token's expiry. None of them is accepted here: the first
+      # two are Meta's answer about provenance, so a value you sent could assert a
+      # partnership Meta disagrees with, and the token is minted per client business and
+      # rotates roughly every sixty days.
+      #
+      # `phone_number_id` is optional. Omit it to connect the account now and settle the
+      # number later — the channel reads as `ACTION_NEEDED` with `reason_code`
+      # `CHANNEL_007`, and the profile's WhatsApp messages fail until a number is named.
+      # They do not fall back to your organization's account.
+      # `POST /v3/channels/whatsapp` connects an account to an existing profile and
+      # resolves the same fields the same way.
+      #
+      # An account of its own needs a sender of its own, so `channels.whatsapp` requires
+      # `channels.sms`. A profile sending SMS on your organization's sender shares that
+      # inbox and opt-out list, and is not a separate tenant to give an account to —
+      # asking is refused with `400`, before your organization is asked to resolve
+      # anything.
+      #
+      # `channels.rcs` records the RCS agent. RCS (Rich Communication Services) is the
+      # next-generation SMS standard built into Android — it lets you send branded
+      # messages with images, buttons and read receipts over the carrier network, with
+      # no app install required. Learn more in the
+      # [Google RCS documentation](https://developers.google.com/business-communications/rcs-business-messaging).
+      #
+      # All fields on the agent form are required except `opt_in_screenshot_url`. The
+      # full form must be submitted in one go so the carrier review has everything it
+      # needs. A carrier approval no API call can trigger is arranged offline, so the
+      # status reports `PROVISIONING` until it is.
+      #
+      # ## Responses
+      #
+      # `201` when the profile is complete on return — the fully-inherited case, where
+      # nothing needs registering. `202` when something is still provisioning, with
+      # per-capability status and outstanding requirements. `409` when the WhatsApp
+      # account supplied is already recorded. `400` covers a wrong value as well as a
+      # missing one: a missing brand under `TEN_DLC`, a brand or campaign inherited
+      # under `TEN_DLC` that your organization does not have yet, an unknown compliance
+      # key, a bad type, a sender id the market does not allow, a `waba_id` that is not
+      # one of the accounts shared into your organization, or a WhatsApp account Meta
+      # rejects. `502` when Meta could not be reached to verify the WhatsApp account;
+      # nothing was created, so retry.
+      sig do
+        params(
+          billing: T.nilable(Sentdm::SenderProfileBillingRequest::OrHash),
+          channels: T.nilable(Sentdm::SenderProfileChannels::OrHash),
+          compliance: Sentdm::Channels::MarketCompliance::OrHash,
+          description: T.nilable(String),
+          name: String,
+          notifications: T.nilable(String),
+          sandbox: T::Boolean,
+          short_name: String,
+          idempotency_key: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(Sentdm::APIResponseOfSenderProfile)
+      end
+      def create(
+        # Body param: Who pays for what a sender profile sends.
+        #
+        # Ownership reads the same way as BrandRequest and CampaignRequest: inherit: true
+        # is the organization paying; inherit: false (or an empty block) is the profile
+        # paying for itself.
+        #
+        # An absent block is the one place billing differs from brand and campaign: a
+        # profile still has to be paid for, so omitting billing stores
+        # ProfileAndOrganizationBilling — the profile pays first and its organization
+        # covers what the profile's balance cannot (see ResolveStored). { "name": "..." }
+        # stays a complete request.
+        #
+        # Billing carries no fields of its own yet, so a profile paying for itself is {
+        # "inherit": false } — or an empty block, which means the same. That is thinner
+        # than brand and campaign, where supplying data is the act of owning; it becomes
+        # ordinary the moment billing gains a contact or a payment method to carry.
+        billing: nil,
+        # Body param: The channels the profile sends on. Each is independently the
+        # profile's own or absent — none can be inherited, so none carries a mode and
+        # presence is the whole of the request.
+        #
+        # A profile can send SMS in several markets, but create takes one — the market it
+        # starts in. Further markets are added through POST /v3/channels/sms with
+        # x-profile-id, and a read returns them all as a list. Create stays singular
+        # permanently rather than being a list that accepts one entry: the constraint is
+        # in the type, and there is no later widening to break the contract.
+        channels: nil,
+        # Body param: The compliance values a market registers with. `brand` and
+        # `campaign` apply to US `TEN_DLC`; other markets fill this map with the document
+        # keys their own requirements name.
+        compliance: nil,
+        # Body param
+        description: nil,
+        # Body param: Display name for the profile. Required.
+        name: nil,
+        # Body param: Who is notified about this profile's events: ORGANIZATION,
+        # SENDER_PROFILE, or ORGANIZATION_AND_SENDER_PROFILE. Omitting it leaves the
+        # profile on the Organization default.
+        notifications: nil,
+        # Body param: Sandbox flag - when true, the operation is simulated without side
+        # effects Useful for testing integrations without actual execution
+        sandbox: nil,
+        # Body param: Short name, which is also the SMS sender id — required. 3–11
+        # characters of letters, numbers and spaces, with at least one letter.
+        short_name: nil,
+        # Header param: Unique key to ensure idempotent request processing. Must be 1-255
+        # alphanumeric characters, hyphens, or underscores. Responses are cached for 24
+        # hours per key per customer.
+        idempotency_key: nil,
+        request_options: {}
+      )
+      end
+
+      # Reads one of your sender profiles.
+      #
+      # The document mirrors `POST /v3/sender-profiles`, with three differences that
+      # follow from this being a read rather than a request.
+      #
+      # `channels.sms` is a **list**. Create takes the one market a profile starts in; a
+      # profile can go on to send in several, and this reports all of them, each with
+      # its own `status`.
+      #
+      # `compliance.brand` comes back **in full, with `inherit` saying whose it is**. On
+      # a request `{ "inherit": true }` carries no data because there is nothing to
+      # send; here it carries the data, because the point of a read is to say what the
+      # profile actually sends under.
+      #
+      # **There is no `campaigns` array.** Brand, campaign, and compliance documents are
+      # reported at the profile root in `compliance`. A profile running on your
+      # organization's campaign is asked for none of the campaign fields, so
+      # `compliance.campaign` carries `{ "inherit": true }` with no campaign data.
+      #
+      # `api_key` is **never** returned here. It is shown once, by create.
+      #
+      # A profile belonging to another organization reads as `404`, not `403`: saying
+      # which of the two it is would confirm the id exists.
+      sig do
+        params(
+          id: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(Sentdm::APIResponseOfSenderProfile)
+      end
+      def retrieve(
+        # Identifier of the profile, as returned by POST /v3/sender-profiles.
+        id,
+        request_options: {}
+      )
+      end
+
+      # Changes a profile's own attributes: `name`, `short_name`, `description` and
+      # `notifications` (who is emailed about the profile's events — `ORGANIZATION`,
+      # `SENDER_PROFILE`, or `ORGANIZATION_AND_SENDER_PROFILE`).
+      #
+      # **Only those.** A profile's identity, its markets and its compliance each have a
+      # sub-resource of their own, because each has its own validation and its own
+      # external consequences — a brand change may need re-registering, a market change
+      # provisions a sender. Folding them in here would give those fields two writers
+      # and no way to say which one wins.
+      #
+      # Omitting a field leaves it alone; sending `null` clears it. Those are different
+      # requests, so `{}` changes nothing and is refused rather than silently accepted —
+      # a caller who misspelt every field would otherwise get a `200` and an unchanged
+      # profile.
+      #
+      # `name` and `short_name` cannot be cleared: `short_name` is the SMS sender id, so
+      # a supplied value must be 3–11 characters of letters, numbers and spaces with at
+      # least one letter.
+      #
+      # Returns the profile as `GET /v3/sender-profiles/{id}` would, so the result of
+      # the change needs no second call to see.
+      sig do
+        params(
+          id: String,
+          description: T.nilable(String),
+          name: String,
+          notifications: T.nilable(String),
+          sandbox: T::Boolean,
+          short_name: T.nilable(String),
+          idempotency_key: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(Sentdm::APIResponseOfSenderProfile)
+      end
+      def update(
+        # Path param
+        id,
+        # Body param
+        description: nil,
+        # Body param
+        name: nil,
+        # Body param: Who is notified about this profile's events: ORGANIZATION,
+        # SENDER_PROFILE, or ORGANIZATION_AND_SENDER_PROFILE. Cannot be cleared — a
+        # supplied value must be one of those.
+        notifications: nil,
+        # Body param: Sandbox flag - when true, the operation is simulated without side
+        # effects Useful for testing integrations without actual execution
+        sandbox: nil,
+        # Body param
+        short_name: nil,
+        # Header param: Unique key to ensure idempotent request processing. Must be 1-255
+        # alphanumeric characters, hyphens, or underscores. Responses are cached for 24
+        # hours per key per customer.
+        idempotency_key: nil,
+        request_options: {}
+      )
+      end
+
+      # Lists the sender profiles under your organization, newest first, paginated with
+      # `page` and `page_size`.
+      #
+      # Each entry is the same document `GET /v3/sender-profiles/{id}` returns, with one
+      # difference: **`compliance.documents` at the profile root is absent**. Working
+      # out which documents a market holds means a catalog lookup and a document read
+      # per market, and doing that for every profile on a page would turn one request
+      # into dozens to answer a question you did not ask. Read a single profile for
+      # that. Brand and campaign are still included when they exist.
+      #
+      # `compliance.documents` being **absent** is not the same as it being an **empty
+      # list**. Absent means the documents were not fetched here; an empty list means
+      # the profile holds none.
+      #
+      # `api_key` is never returned. It is shown once, by create.
+      sig do
+        params(
+          page: Integer,
+          page_size: Integer,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(Sentdm::Internal::SenderProfilesPage[Sentdm::SenderProfile])
+      end
+      def list(
+        # Page number, 1-indexed.
+        page: nil,
+        # Profiles per page. Between 1 and 100.
+        page_size: nil,
+        request_options: {}
+      )
+      end
+
+      # Deletes one of your sender profiles and returns `204`.
+      #
+      # The delete is **soft**: the profile stops being usable and stops appearing in
+      # reads, and its message history is kept, because deleting a profile must not
+      # delete the record of what it sent.
+      #
+      # ## What it releases
+      #
+      # Anything the profile still held goes with it. A **phone number** returns to our
+      # inventory and can be given to whoever asks next — it does not stay reserved for
+      # you, and getting the same number back afterwards is not something we can
+      # promise. A **WhatsApp account of its own** is deregistered from Meta. Its
+      # routing rules stop being used, so nothing sends through the profile after this
+      # call.
+      #
+      # A profile that only inherits from its organization holds nothing of its own and
+      # releases nothing.
+      #
+      # ## When it is refused
+      #
+      # A number the profile holds that your **WhatsApp Business Account still carries**
+      # refuses the delete with a `409 CONFLICT_012`, and nothing is deleted: it would
+      # return to our shared inventory while Meta still routes WhatsApp to it, and the
+      # next customer given it could not register it at all. Only you can take it off
+      # the account — deregister **and** delete it in WhatsApp Manager, then try again.
+      # A `409 CONFLICT_013` means we could not read the account, so we cannot tell
+      # either way.
+      sig do
+        params(id: String, request_options: Sentdm::RequestOptions::OrHash).void
+      end
+      def delete(
+        # Identifier of the profile.
+        id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Sentdm::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/sentdm/resources/users.rbi

@@ -35,7 +35,7 @@ module Sentdm
         params(
           x_profile_id: String,
           request_options: Sentdm::RequestOptions::OrHash
-        ).returns(Sentdm::Models::UserListResponse)
+        ).returns(Sentdm::APIResponseOfUsersList)
       end
       def list(
         # Profile UUID to scope the request to a child profile. Only organization API keys

data/rbi/sentdm/resources/voice/calls/participants.rbi

@@ -102,11 +102,11 @@ module Sentdm
           # conference room, and answers with the participant's own call record. The
           # participant is a call of their own: it has its own id, can be looked up and hung
           # up, and is billed and reported through call.completed and call.failed like any
-          # other call. Every participant needs a positive balance. A phone participant is
-          # called from caller_id, which must be one of your numbers, or from the call's
-          # owning number when omitted, and needs a destination you may call. Only a call
-          # your answer connected to a conference can take participants: a call connected to
-          # a user or a number answers 409.
+          # other call. Every participant needs a payment method on file and a positive
+          # balance. A phone participant is called from caller_id, which must be one of your
+          # numbers, or from the call's owning number when omitted, and needs a destination
+          # you may call. Only a call your answer connected to a conference can take
+          # participants: a call connected to a user or a number answers 409.
           sig do
             params(
               id: String,

data/rbi/sentdm/resources/webhooks.rbi

@@ -32,8 +32,7 @@ module Sentdm
           is_inheritable: T::Boolean,
           retry_count: Integer,
           sandbox: T::Boolean,
-          sender_profile:
-            T.nilable(Sentdm::WebhookCreateParams::SenderProfile::OrHash),
+          sender_profile: T.nilable(Sentdm::WebhookSenderProfileConfig::OrHash),
           timeout_seconds: Integer,
           webhook_version: T.nilable(Integer),
           idempotency_key: String,
@@ -117,8 +116,7 @@ module Sentdm
           is_inheritable: T.nilable(T::Boolean),
           retry_count: Integer,
           sandbox: T::Boolean,
-          sender_profile:
-            T.nilable(Sentdm::WebhookUpdateParams::SenderProfile::OrHash),
+          sender_profile: T.nilable(Sentdm::WebhookSenderProfileConfig::OrHash),
           timeout_seconds: Integer,
           idempotency_key: String,
           x_profile_id: String,
@@ -214,7 +212,7 @@ module Sentdm
         params(
           x_profile_id: String,
           request_options: Sentdm::RequestOptions::OrHash
-        ).returns(Sentdm::Models::WebhookListEventTypesResponse)
+        ).returns(Sentdm::APIResponseOfWebhookEventTypesList)
       end
       def list_event_types(
         # Profile UUID to scope the request to a child profile. Only organization API keys
@@ -237,11 +235,7 @@ module Sentdm
           search: T.nilable(String),
           x_profile_id: String,
           request_options: Sentdm::RequestOptions::OrHash
-        ).returns(
-          Sentdm::Internal::WebhookEventsPage[
-            Sentdm::Models::WebhookListEventsResponse
-          ]
-        )
+        ).returns(Sentdm::Internal::WebhookEventsPage[Sentdm::WebhookDelivery])
       end
       def list_events(
         # Path param
@@ -272,7 +266,7 @@ module Sentdm
           idempotency_key: String,
           x_profile_id: String,
           request_options: Sentdm::RequestOptions::OrHash
-        ).returns(Sentdm::Models::WebhookRotateSecretResponse)
+        ).returns(Sentdm::APIResponseOfWebhookSecret)
       end
       def rotate_secret(
         # Path param
@@ -304,7 +298,7 @@ module Sentdm
           idempotency_key: String,
           x_profile_id: String,
           request_options: Sentdm::RequestOptions::OrHash
-        ).returns(Sentdm::Models::WebhookTestResponse)
+        ).returns(Sentdm::APIResponseOfWebhookTest)
       end
       def test_(
         # Path param

data/sig/sentdm/client.rbs

@@ -18,6 +18,8 @@ module Sentdm
 
     attr_reader profiles: Sentdm::Resources::Profiles
 
+    attr_reader sender_profiles: Sentdm::Resources::SenderProfiles
+
     attr_reader numbers: Sentdm::Resources::Numbers
 
     attr_reader messages: Sentdm::Resources::Messages
@@ -30,6 +32,8 @@ module Sentdm
 
     attr_reader channels: Sentdm::Resources::Channels
 
+    attr_reader compliance: Sentdm::Resources::Compliance
+
     attr_reader me: Sentdm::Resources::Me
 
     private def auth_headers: -> ::Hash[String, String]

data/sig/sentdm/internal/sender_profiles_page.rbs

@@ -0,0 +1,80 @@
+module Sentdm
+  module Internal
+    class SenderProfilesPage[Elem]
+      include Sentdm::Internal::Type::BasePage[Elem]
+
+      attr_accessor data: Data
+
+      def inspect: -> String
+
+      type data =
+        { pagination: Data::Pagination, sender_profiles: ::Array[top] }
+      class Data < Sentdm::Internal::Type::BaseModel
+        attr_reader pagination: Data::Pagination?
+
+        def pagination=: (Data::Pagination) -> Data::Pagination
+
+        attr_reader sender_profiles: ::Array[top]?
+
+        def sender_profiles=: (::Array[top]) -> ::Array[top]
+
+        def initialize: (
+          ?pagination: Data::Pagination,
+          ?sender_profiles: ::Array[top]
+        ) -> void
+
+        def to_hash: -> {
+          pagination: Data::Pagination,
+          sender_profiles: ::Array[top]
+        }
+
+        type pagination =
+          {
+            has_more: bool,
+            page: Integer,
+            page_size: Integer,
+            total_count: Integer,
+            total_pages: Integer
+          }
+
+        class Pagination < Sentdm::Internal::Type::BaseModel
+          attr_reader has_more: bool?
+
+          def has_more=: (bool) -> bool
+
+          attr_reader page: Integer?
+
+          def page=: (Integer) -> Integer
+
+          attr_reader page_size: Integer?
+
+          def page_size=: (Integer) -> Integer
+
+          attr_reader total_count: Integer?
+
+          def total_count=: (Integer) -> Integer
+
+          attr_reader total_pages: Integer?
+
+          def total_pages=: (Integer) -> Integer
+
+          def initialize: (
+            ?has_more: bool,
+            ?page: Integer,
+            ?page_size: Integer,
+            ?total_count: Integer,
+            ?total_pages: Integer
+          ) -> void
+
+          def to_hash: -> {
+            has_more: bool,
+            page: Integer,
+            page_size: Integer,
+            total_count: Integer,
+            total_pages: Integer
+          }
+        end
+      end
+    end
+  end
+end