sentdm 0.44.0 → 0.46.0

data/rbi/sentdm/models/channels/rcs_agent.rbi

@@ -0,0 +1,320 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class RcsAgent < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::RcsAgent, Sentdm::Internal::AnyHash)
+          end
+
+        # The agent record. Stable across the whole approval, and what support will ask
+        # for.
+        #
+        # Nullable and omitted when absent: a sender profile with RCS intent records the
+        # channel but has no agent until the order form is submitted, so no id exists to
+        # report. A zero GUID is not a valid id and is worse than the field being absent.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :agent_use_case
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :brand_color
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :brand_email
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :brand_name
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :brand_phone_number
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :brief_company_description
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :company_ein
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :contact_name_and_title
+
+        # Omitted when no real agent record exists — the intent-only path has no creation
+        # timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :created_at
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_support_email
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_support_phone_number
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :description
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :display_name
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :entity_type
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :help_message
+
+        # The registered address of the company behind the agent.
+        sig { returns(T.nilable(Sentdm::Channels::RcsAddress)) }
+        attr_reader :official_address
+
+        sig do
+          params(
+            official_address: T.nilable(Sentdm::Channels::RcsAddress::OrHash)
+          ).void
+        end
+        attr_writer :official_address
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :opt_in_process_description
+
+        # The number the agent sends from, derived from brand_phone_number.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :privacy_policy_url
+
+        # A sentence for reason_code, saying what to do where it is yours. Omitted while
+        # ACTIVE.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # Why the agent is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+        # such as CHANNEL_001 (something you owe) or CHANNEL_009 (under review). Switch on
+        # this rather than on reason. Omitted while ACTIVE. Read-only; when nothing more
+        # specific is known it is the generic reason for the status.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason_code
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :sample_messages
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :start_message
+
+        # Where the agent stands, in terms of who is holding it up — PROVISIONING,
+        # ACTION_NEEDED, PENDING_REVIEW or ACTIVE.
+        #
+        # Resolved from both of the provider's axes rather than reported raw: an agent
+        # whose resubmission we have asked for reads ACTION_NEEDED however its carrier
+        # status still reads, and an agent not yet handed over reads PROVISIONING rather
+        # than pending a review nobody has started.
+        sig do
+          returns(T.nilable(Sentdm::Channels::RcsAgent::Status::TaggedSymbol))
+        end
+        attr_accessor :status
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :stop_message
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :terms_and_conditions_url
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :website_url
+
+        # An RCS agent as its owner sees it: the order form back, plus where the
+        # submission stands.
+        #
+        # Not RcsSenderResponse. That one is the admin projection and carries the pipeline
+        # we track about a customer's request — internalStatus, statusReason, isLaunched —
+        # and the S3 keys behind the assets. None of that is the customer's to read: an
+        # internal status is a note to ourselves, and an S3 key is a storage detail that
+        # would become a contract the moment it was published.
+        #
+        # What is here is what the caller sent, in the names it sent them under, plus the
+        # three things only we can answer: the record's id, its status, and the number it
+        # sends from. So a read after a write shows the form as stored rather than as
+        # echoed.
+        sig do
+          params(
+            id: T.nilable(String),
+            agent_use_case: T.nilable(String),
+            brand_color: T.nilable(String),
+            brand_email: T.nilable(String),
+            brand_name: T.nilable(String),
+            brand_phone_number: T.nilable(String),
+            brief_company_description: T.nilable(String),
+            company_ein: T.nilable(String),
+            contact_name_and_title: T.nilable(String),
+            created_at: T.nilable(Time),
+            customer_support_email: T.nilable(String),
+            customer_support_phone_number: T.nilable(String),
+            description: T.nilable(String),
+            display_name: T.nilable(String),
+            entity_type: T.nilable(String),
+            help_message: T.nilable(String),
+            official_address: T.nilable(Sentdm::Channels::RcsAddress::OrHash),
+            opt_in_process_description: T.nilable(String),
+            phone_number: T.nilable(String),
+            privacy_policy_url: T.nilable(String),
+            reason: T.nilable(String),
+            reason_code: T.nilable(String),
+            sample_messages: T.nilable(T::Array[String]),
+            start_message: T.nilable(String),
+            status: T.nilable(Sentdm::Channels::RcsAgent::Status::OrSymbol),
+            stop_message: T.nilable(String),
+            terms_and_conditions_url: T.nilable(String),
+            website_url: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The agent record. Stable across the whole approval, and what support will ask
+          # for.
+          #
+          # Nullable and omitted when absent: a sender profile with RCS intent records the
+          # channel but has no agent until the order form is submitted, so no id exists to
+          # report. A zero GUID is not a valid id and is worse than the field being absent.
+          id: nil,
+          agent_use_case: nil,
+          brand_color: nil,
+          brand_email: nil,
+          brand_name: nil,
+          brand_phone_number: nil,
+          brief_company_description: nil,
+          company_ein: nil,
+          contact_name_and_title: nil,
+          # Omitted when no real agent record exists — the intent-only path has no creation
+          # timestamp.
+          created_at: nil,
+          customer_support_email: nil,
+          customer_support_phone_number: nil,
+          description: nil,
+          display_name: nil,
+          entity_type: nil,
+          help_message: nil,
+          # The registered address of the company behind the agent.
+          official_address: nil,
+          opt_in_process_description: nil,
+          # The number the agent sends from, derived from brand_phone_number.
+          phone_number: nil,
+          privacy_policy_url: nil,
+          # A sentence for reason_code, saying what to do where it is yours. Omitted while
+          # ACTIVE.
+          reason: nil,
+          # Why the agent is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+          # such as CHANNEL_001 (something you owe) or CHANNEL_009 (under review). Switch on
+          # this rather than on reason. Omitted while ACTIVE. Read-only; when nothing more
+          # specific is known it is the generic reason for the status.
+          reason_code: nil,
+          sample_messages: nil,
+          start_message: nil,
+          # Where the agent stands, in terms of who is holding it up — PROVISIONING,
+          # ACTION_NEEDED, PENDING_REVIEW or ACTIVE.
+          #
+          # Resolved from both of the provider's axes rather than reported raw: an agent
+          # whose resubmission we have asked for reads ACTION_NEEDED however its carrier
+          # status still reads, and an agent not yet handed over reads PROVISIONING rather
+          # than pending a review nobody has started.
+          status: nil,
+          stop_message: nil,
+          terms_and_conditions_url: nil,
+          website_url: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: T.nilable(String),
+              agent_use_case: T.nilable(String),
+              brand_color: T.nilable(String),
+              brand_email: T.nilable(String),
+              brand_name: T.nilable(String),
+              brand_phone_number: T.nilable(String),
+              brief_company_description: T.nilable(String),
+              company_ein: T.nilable(String),
+              contact_name_and_title: T.nilable(String),
+              created_at: T.nilable(Time),
+              customer_support_email: T.nilable(String),
+              customer_support_phone_number: T.nilable(String),
+              description: T.nilable(String),
+              display_name: T.nilable(String),
+              entity_type: T.nilable(String),
+              help_message: T.nilable(String),
+              official_address: T.nilable(Sentdm::Channels::RcsAddress),
+              opt_in_process_description: T.nilable(String),
+              phone_number: T.nilable(String),
+              privacy_policy_url: T.nilable(String),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String),
+              sample_messages: T.nilable(T::Array[String]),
+              start_message: T.nilable(String),
+              status:
+                T.nilable(Sentdm::Channels::RcsAgent::Status::TaggedSymbol),
+              stop_message: T.nilable(String),
+              terms_and_conditions_url: T.nilable(String),
+              website_url: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Where the agent stands, in terms of who is holding it up — PROVISIONING,
+        # ACTION_NEEDED, PENDING_REVIEW or ACTIVE.
+        #
+        # Resolved from both of the provider's axes rather than reported raw: an agent
+        # whose resubmission we have asked for reads ACTION_NEEDED however its carrier
+        # status still reads, and an agent not yet handed over reads PROVISIONING rather
+        # than pending a review nobody has started.
+        module Status
+          extend Sentdm::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Sentdm::Channels::RcsAgent::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # We are working on it and there is nothing for you to do — a number is being procured, or a registration is being assembled. Minutes to hours.
+          PROVISIONING =
+            T.let(
+              :PROVISIONING,
+              Sentdm::Channels::RcsAgent::Status::TaggedSymbol
+            )
+
+          # **Waiting on you.** Something the market asks for has not been supplied, a regulator rejected what was, or we have asked you to correct and resubmit your identity data. Nothing progresses until you act. For an SMS market, `GET /v3/channels/sms/{country}/{type}` names what it wants and `PATCH` on the same path supplies it — compliance values, documents and numbers alike.
+          ACTION_NEEDED =
+            T.let(
+              :ACTION_NEEDED,
+              Sentdm::Channels::RcsAgent::Status::TaggedSymbol
+            )
+
+          # With a regulator or carrier — filed, or assembled and queued for us to file — and their answer is what moves it, to `ACTIVE` or back to `ACTION_NEEDED`. Nothing on your side changes it. Days for SMS, weeks for RCS.
+          PENDING_REVIEW =
+            T.let(
+              :PENDING_REVIEW,
+              Sentdm::Channels::RcsAgent::Status::TaggedSymbol
+            )
+
+          # Can carry traffic now. A channel a sender profile runs on its organization's reads `ACTIVE` too — it sends, which is what the field is about.
+          ACTIVE =
+            T.let(:ACTIVE, Sentdm::Channels::RcsAgent::Status::TaggedSymbol)
+
+          # **It had a working sender and no longer does** — the number was released, or the campaign it carried lapsed. Distinct from `PROVISIONING`, which means it has never sent yet: the same absence of a sender, opposite news. Sends will fail until it returns to `ACTIVE`.
+          INACTIVE =
+            T.let(:INACTIVE, Sentdm::Channels::RcsAgent::Status::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Sentdm::Channels::RcsAgent::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/sms_create_params.rbi

@@ -0,0 +1,291 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class SMSCreateParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::SMSCreateParams, Sentdm::Internal::AnyHash)
+          end
+
+        # Sender type. Decides the provisioning flow and what compliance is asked for.
+        #
+        # [Required] so the published document says so. The validator has always demanded
+        # it, but requiredness reached the schema by matching a rule to a property name —
+        # which works for country, whose wire name is its camel-cased C# name, and
+        # silently does not for number_type. A client generating a request from our
+        # OpenAPI therefore sent what the document called sufficient and was answered 400.
+        sig { returns(Sentdm::Channels::SMSCreateParams::NumberType::OrSymbol) }
+        attr_accessor :number_type
+
+        # The area codes to put this sender in, in your own order of preference, e.g.
+        # ["415", "628"] for the US or ["20"] for London. Omit it and a number is claimed
+        # anywhere in the country.
+        #
+        # Ordered, and the order is the request. The claim tries each code in turn and
+        # stops at the first that yields a number. Nothing sorts the list and a code
+        # listed twice is refused.
+        #
+        # One to fifty entries, each the area code as digits: 415, with the trunk prefix
+        # as 020, or with the country's dialing prefix as +1415 (all are stored as the
+        # bare code). A dialing prefix from a different country than country is refused.
+        # Each code is checked against the country's numbering plan: it must start real
+        # local or mobile numbers there, so toll-free and premium ranges, service codes
+        # and another country's codes are refused with a reason.
+        #
+        # LOCAL senders in any country, and US TEN_DLC senders. No other sender type has a
+        # geographic area code, and the list is refused with one rather than accepted and
+        # dropped.
+        #
+        # Honoured exactly or not at all. Ask for 415 and you get a 415 number or you get
+        # none, never a neighbouring code you did not name. A miss leaves the market with
+        # no sender yet and the codes recorded on it, so it is filled when stock appears
+        # rather than filled now from somewhere else. Many countries outside North America
+        # require address or business documents before a local number can be bought, which
+        # can delay or prevent the fill.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :area_codes
+
+        # 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.
+        sig { returns(T.nilable(Sentdm::Channels::MarketCompliance)) }
+        attr_reader :compliance
+
+        sig do
+          params(compliance: Sentdm::Channels::MarketCompliance::OrHash).void
+        end
+        attr_writer :compliance
+
+        # ISO 3166-1 alpha-2 country the sender operates in.
+        sig { returns(T.nilable(String)) }
+        attr_reader :country
+
+        sig { params(country: String).void }
+        attr_writer :country
+
+        # The numbers to assign, one entry per area code, e.g. [{"area_code": "212",
+        # "quantity": 2}, {"area_code": "415"}, {"quantity": 1}]: two numbers in 212, one
+        # in 415 and one in any area code. quantity defaults to 1, and an entry without
+        # area_code means any area code. Omit numbers for one number.
+        #
+        # Only with LOCAL or TEN_DLC, and not together with area_codes. Each area code is
+        # validated against country the same way area_codes is and may appear once, and at
+        # most one entry may leave area_code out. On a LOCAL market you already hold, this
+        # adds the numbers to it. US TEN_DLC numbers are assigned when the campaign is
+        # approved, not at request time. Not available when the profile inherits the
+        # organization's campaign.
+        sig { returns(T.nilable(T::Array[Sentdm::Channels::SMSNumberRequest])) }
+        attr_accessor :numbers
+
+        # Sandbox flag - when true, the operation is simulated without side effects Useful
+        # for testing integrations without actual execution
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :sandbox
+
+        sig { params(sandbox: T::Boolean).void }
+        attr_writer :sandbox
+
+        # The sender's identity where the caller chooses it. Required when number_type is
+        # ALPHANUMERIC; optional for carrier-assigned types, which are procured
+        # afterwards.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :sender_value
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :x_profile_id
+
+        sig { params(x_profile_id: String).void }
+        attr_writer :x_profile_id
+
+        sig do
+          params(
+            number_type:
+              Sentdm::Channels::SMSCreateParams::NumberType::OrSymbol,
+            area_codes: T.nilable(T::Array[String]),
+            compliance: Sentdm::Channels::MarketCompliance::OrHash,
+            country: String,
+            numbers:
+              T.nilable(T::Array[Sentdm::Channels::SMSNumberRequest::OrHash]),
+            sandbox: T::Boolean,
+            sender_value: T.nilable(String),
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Sender type. Decides the provisioning flow and what compliance is asked for.
+          #
+          # [Required] so the published document says so. The validator has always demanded
+          # it, but requiredness reached the schema by matching a rule to a property name —
+          # which works for country, whose wire name is its camel-cased C# name, and
+          # silently does not for number_type. A client generating a request from our
+          # OpenAPI therefore sent what the document called sufficient and was answered 400.
+          number_type:,
+          # The area codes to put this sender in, in your own order of preference, e.g.
+          # ["415", "628"] for the US or ["20"] for London. Omit it and a number is claimed
+          # anywhere in the country.
+          #
+          # Ordered, and the order is the request. The claim tries each code in turn and
+          # stops at the first that yields a number. Nothing sorts the list and a code
+          # listed twice is refused.
+          #
+          # One to fifty entries, each the area code as digits: 415, with the trunk prefix
+          # as 020, or with the country's dialing prefix as +1415 (all are stored as the
+          # bare code). A dialing prefix from a different country than country is refused.
+          # Each code is checked against the country's numbering plan: it must start real
+          # local or mobile numbers there, so toll-free and premium ranges, service codes
+          # and another country's codes are refused with a reason.
+          #
+          # LOCAL senders in any country, and US TEN_DLC senders. No other sender type has a
+          # geographic area code, and the list is refused with one rather than accepted and
+          # dropped.
+          #
+          # Honoured exactly or not at all. Ask for 415 and you get a 415 number or you get
+          # none, never a neighbouring code you did not name. A miss leaves the market with
+          # no sender yet and the codes recorded on it, so it is filled when stock appears
+          # rather than filled now from somewhere else. Many countries outside North America
+          # require address or business documents before a local number can be bought, which
+          # can delay or prevent the fill.
+          area_codes: nil,
+          # 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,
+          # ISO 3166-1 alpha-2 country the sender operates in.
+          country: nil,
+          # The numbers to assign, one entry per area code, e.g. [{"area_code": "212",
+          # "quantity": 2}, {"area_code": "415"}, {"quantity": 1}]: two numbers in 212, one
+          # in 415 and one in any area code. quantity defaults to 1, and an entry without
+          # area_code means any area code. Omit numbers for one number.
+          #
+          # Only with LOCAL or TEN_DLC, and not together with area_codes. Each area code is
+          # validated against country the same way area_codes is and may appear once, and at
+          # most one entry may leave area_code out. On a LOCAL market you already hold, this
+          # adds the numbers to it. US TEN_DLC numbers are assigned when the campaign is
+          # approved, not at request time. Not available when the profile inherits the
+          # organization's campaign.
+          numbers: nil,
+          # Sandbox flag - when true, the operation is simulated without side effects Useful
+          # for testing integrations without actual execution
+          sandbox: nil,
+          # The sender's identity where the caller chooses it. Required when number_type is
+          # ALPHANUMERIC; optional for carrier-assigned types, which are procured
+          # afterwards.
+          sender_value: nil,
+          idempotency_key: nil,
+          x_profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              number_type:
+                Sentdm::Channels::SMSCreateParams::NumberType::OrSymbol,
+              area_codes: T.nilable(T::Array[String]),
+              compliance: Sentdm::Channels::MarketCompliance,
+              country: String,
+              numbers: T.nilable(T::Array[Sentdm::Channels::SMSNumberRequest]),
+              sandbox: T::Boolean,
+              sender_value: T.nilable(String),
+              idempotency_key: String,
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Sender type. Decides the provisioning flow and what compliance is asked for.
+        #
+        # [Required] so the published document says so. The validator has always demanded
+        # it, but requiredness reached the schema by matching a rule to a property name —
+        # which works for country, whose wire name is its camel-cased C# name, and
+        # silently does not for number_type. A client generating a request from our
+        # OpenAPI therefore sent what the document called sufficient and was answered 400.
+        module NumberType
+          extend Sentdm::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Sentdm::Channels::SMSCreateParams::NumberType)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # A geographic number for the country. The ordinary choice: recognisable to recipients, and available almost everywhere.
+          LOCAL =
+            T.let(
+              :LOCAL,
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          # A toll-free number. High throughput and no per-country registration, but US toll-free traffic goes through its own verification.
+          TOLL_FREE =
+            T.let(
+              :TOLL_FREE,
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          # A short code — five or six digits, leased rather than provisioned. Highest throughput, longest lead time, and the most expensive.
+          SHORT_CODE =
+            T.let(
+              :SHORT_CODE,
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          # A sender name rather than a number, up to 11 characters. Recipients cannot reply. Not available in every country, and several require it to be pre-registered with documents.
+          ALPHANUMERIC =
+            T.let(
+              :ALPHANUMERIC,
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          # A US 10-digit long code registered with The Campaign Registry. The only sender type that registers with a compliance regime, so it is the only one whose market declares `compliance.brand` and `compliance.campaign`.
+          TEN_DLC =
+            T.let(
+              :TEN_DLC,
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          # A mobile number. Where a country distinguishes it from a landline, some carriers treat mobile traffic differently.
+          MOBILE =
+            T.let(
+              :MOBILE,
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          # The industry's spelling of `TEN_DLC`, accepted so an integrator can send the term it knows. Resolves to the same market.
+          NUMBER_TYPE_10_DLC =
+            T.let(
+              :"10DLC",
+              Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Sentdm::Channels::SMSCreateParams::NumberType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/sms_list_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class SMSListParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::SMSListParams, Sentdm::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :x_profile_id
+
+        sig { params(x_profile_id: String).void }
+        attr_writer :x_profile_id
+
+        sig do
+          params(
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(x_profile_id: nil, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { x_profile_id: String, request_options: Sentdm::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end