rcs 1.0.18 → 2.0.0.pre.rc.1

data/lib/rcs/messages/send/client.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "types/send_sms_schema_options"
+require_relative "types/send_sms_response"
+require_relative "types/send_mms_schema_options"
+require_relative "types/send_mms_response"
+require_relative "../../types/rcs"
+require_relative "types/send_rcs_response"
+require "async"
+
+module Pinnacle
+  module Messages
+    class SendClient
+      # @return [Pinnacle::RequestClient]
+      attr_reader :request_client
+
+      # @param request_client [Pinnacle::RequestClient]
+      # @return [Pinnacle::Messages::SendClient]
+      def initialize(request_client:)
+        @request_client = request_client
+      end
+
+      # Send a SMS message immediately or schedule it for future delivery.
+      #
+      # @param from [String] Phone number that sends the message in E.164 format.
+      # @param options [Hash] Additional settings to customize SMS delivery.Request of type Pinnacle::Messages::Send::Types::SendSmsSchemaOptions, as a Hash
+      #   * :schedule (Hash)
+      #     * :end_date (DateTime)
+      #     * :recurrence (String)
+      #     * :send_at (String)
+      #     * :timezone (String)
+      #   * :tracking (Pinnacle::Types::Tracking)
+      # @param text [String] Message content.
+      # @param to [String] Recipient's phone number in E.164 format.
+      # @param request_options [Pinnacle::RequestOptions]
+      # @return [Pinnacle::Types::SentSmsDetails, Pinnacle::Types::ScheduledMessaage]
+      # @example
+      #  api = Pinnacle::Client.new(
+      #    base_url: "https://api.example.com",
+      #    environment: Pinnacle::Environment::DEFAULT,
+      #    api_key: "YOUR_API_KEY"
+      #  )
+      #  api.messages.send.sms(
+      #    from: "+14155164736",
+      #    text: "Hey! 😂",
+      #    to: "+14154746461"
+      #  )
+      def sms(from:, text:, to:, options: nil, request_options: nil)
+        response = @request_client.conn.post do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["PINNACLE-API-KEY"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = {
+        **(req.headers || {}),
+        **@request_client.get_headers,
+        **(request_options&.additional_headers || {})
+          }.compact
+          unless request_options.nil? || request_options&.additional_query_parameters.nil?
+            req.params = { **(request_options&.additional_query_parameters || {}) }.compact
+          end
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            from: from,
+            options: options,
+            text: text,
+            to: to
+          }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/messages/send/sms"
+        end
+        Pinnacle::Messages::Send::Types::SendSmsResponse.from_json(json_object: response.body)
+      end
+
+      # Send a MMS immediately or schedule it for future delivery.
+      #
+      # @param from [String] Phone number you want to send the message from in E.164 format.
+      # @param media_urls [Array<String>] Media file URLs to send.<br>
+      #  See [supported media
+      #  types](https://app.pinnacle.sh/supported-file-types?type=MMS).
+      # @param options [Hash] Control how your MMS is processed and delivered.Request of type Pinnacle::Messages::Send::Types::SendMmsSchemaOptions, as a Hash
+      #   * :multiple_messages (Boolean)
+      #   * :schedule (Hash)
+      #     * :end_date (DateTime)
+      #     * :recurrence (String)
+      #     * :send_at (String)
+      #     * :timezone (String)
+      #   * :tracking (Pinnacle::Types::Tracking)
+      #   * :validate (Boolean)
+      # @param text [String] Message text to accompany the media.
+      # @param to [String] Recipient's phone number in E.164 format.
+      # @param request_options [Pinnacle::RequestOptions]
+      # @return [Pinnacle::Types::SentMmsDetails, Pinnacle::Types::ScheduledMessaage]
+      # @example
+      #  api = Pinnacle::Client.new(
+      #    base_url: "https://api.example.com",
+      #    environment: Pinnacle::Environment::DEFAULT,
+      #    api_key: "YOUR_API_KEY"
+      #  )
+      #  api.messages.send.mms(
+      #    from: "+14155164736",
+      #    media_urls: ["https://fastly.picsum.photos/id/941/300/300.jpg?hmac=mDxM9PWSqRDjecwSCEpzU4bj35gqnG7yA25OL29uNv0"],
+      #    options: { multiple_messages: true, validate: true },
+      #    text: "Check out this image!",
+      #    to: "+14154746461"
+      #  )
+      def mms(from:, media_urls:, text:, to:, options: nil, request_options: nil)
+        response = @request_client.conn.post do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["PINNACLE-API-KEY"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = {
+        **(req.headers || {}),
+        **@request_client.get_headers,
+        **(request_options&.additional_headers || {})
+          }.compact
+          unless request_options.nil? || request_options&.additional_query_parameters.nil?
+            req.params = { **(request_options&.additional_query_parameters || {}) }.compact
+          end
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            from: from,
+            mediaUrls: media_urls,
+            options: options,
+            text: text,
+            to: to
+          }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/messages/send/mms"
+        end
+        Pinnacle::Messages::Send::Types::SendMmsResponse.from_json(json_object: response.body)
+      end
+
+      # Send a RCS message immediately or schedule it for future delivery. <br>
+      #  Requires an active RCS agent and recipient devices that support RCS Business
+      #  Messaging.
+      #
+      # @param request [Pinnacle::Types::RcsText, Pinnacle::Types::RcsMedia, Pinnacle::Types::RcsCard]
+      # @param request_options [Pinnacle::RequestOptions]
+      # @return [Pinnacle::Types::SentRcsDetails, Pinnacle::Types::ScheduledMessaage]
+      # @example
+      #  api = Pinnacle::Client.new(
+      #    base_url: "https://api.example.com",
+      #    environment: Pinnacle::Environment::DEFAULT,
+      #    api_key: "YOUR_API_KEY"
+      #  )
+      #  api.messages.send.rcs(request: { quick_replies: , text: "text", from: "from", to: "to" })
+      def rcs(request:, request_options: nil)
+        response = @request_client.conn.post do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["PINNACLE-API-KEY"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = {
+        **(req.headers || {}),
+        **@request_client.get_headers,
+        **(request_options&.additional_headers || {})
+          }.compact
+          unless request_options.nil? || request_options&.additional_query_parameters.nil?
+            req.params = { **(request_options&.additional_query_parameters || {}) }.compact
+          end
+          req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+          req.url "#{@request_client.get_url(request_options: request_options)}/messages/send/rcs"
+        end
+        Pinnacle::Messages::Send::Types::SendRcsResponse.from_json(json_object: response.body)
+      end
+    end
+
+    class AsyncSendClient
+      # @return [Pinnacle::AsyncRequestClient]
+      attr_reader :request_client
+
+      # @param request_client [Pinnacle::AsyncRequestClient]
+      # @return [Pinnacle::Messages::AsyncSendClient]
+      def initialize(request_client:)
+        @request_client = request_client
+      end
+
+      # Send a SMS message immediately or schedule it for future delivery.
+      #
+      # @param from [String] Phone number that sends the message in E.164 format.
+      # @param options [Hash] Additional settings to customize SMS delivery.Request of type Pinnacle::Messages::Send::Types::SendSmsSchemaOptions, as a Hash
+      #   * :schedule (Hash)
+      #     * :end_date (DateTime)
+      #     * :recurrence (String)
+      #     * :send_at (String)
+      #     * :timezone (String)
+      #   * :tracking (Pinnacle::Types::Tracking)
+      # @param text [String] Message content.
+      # @param to [String] Recipient's phone number in E.164 format.
+      # @param request_options [Pinnacle::RequestOptions]
+      # @return [Pinnacle::Types::SentSmsDetails, Pinnacle::Types::ScheduledMessaage]
+      # @example
+      #  api = Pinnacle::Client.new(
+      #    base_url: "https://api.example.com",
+      #    environment: Pinnacle::Environment::DEFAULT,
+      #    api_key: "YOUR_API_KEY"
+      #  )
+      #  api.messages.send.sms(
+      #    from: "+14155164736",
+      #    text: "Hey! 😂",
+      #    to: "+14154746461"
+      #  )
+      def sms(from:, text:, to:, options: nil, request_options: nil)
+        Async do
+          response = @request_client.conn.post do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["PINNACLE-API-KEY"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers = {
+          **(req.headers || {}),
+          **@request_client.get_headers,
+          **(request_options&.additional_headers || {})
+            }.compact
+            unless request_options.nil? || request_options&.additional_query_parameters.nil?
+              req.params = { **(request_options&.additional_query_parameters || {}) }.compact
+            end
+            req.body = {
+              **(request_options&.additional_body_parameters || {}),
+              from: from,
+              options: options,
+              text: text,
+              to: to
+            }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/messages/send/sms"
+          end
+          Pinnacle::Messages::Send::Types::SendSmsResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Send a MMS immediately or schedule it for future delivery.
+      #
+      # @param from [String] Phone number you want to send the message from in E.164 format.
+      # @param media_urls [Array<String>] Media file URLs to send.<br>
+      #  See [supported media
+      #  types](https://app.pinnacle.sh/supported-file-types?type=MMS).
+      # @param options [Hash] Control how your MMS is processed and delivered.Request of type Pinnacle::Messages::Send::Types::SendMmsSchemaOptions, as a Hash
+      #   * :multiple_messages (Boolean)
+      #   * :schedule (Hash)
+      #     * :end_date (DateTime)
+      #     * :recurrence (String)
+      #     * :send_at (String)
+      #     * :timezone (String)
+      #   * :tracking (Pinnacle::Types::Tracking)
+      #   * :validate (Boolean)
+      # @param text [String] Message text to accompany the media.
+      # @param to [String] Recipient's phone number in E.164 format.
+      # @param request_options [Pinnacle::RequestOptions]
+      # @return [Pinnacle::Types::SentMmsDetails, Pinnacle::Types::ScheduledMessaage]
+      # @example
+      #  api = Pinnacle::Client.new(
+      #    base_url: "https://api.example.com",
+      #    environment: Pinnacle::Environment::DEFAULT,
+      #    api_key: "YOUR_API_KEY"
+      #  )
+      #  api.messages.send.mms(
+      #    from: "+14155164736",
+      #    media_urls: ["https://fastly.picsum.photos/id/941/300/300.jpg?hmac=mDxM9PWSqRDjecwSCEpzU4bj35gqnG7yA25OL29uNv0"],
+      #    options: { multiple_messages: true, validate: true },
+      #    text: "Check out this image!",
+      #    to: "+14154746461"
+      #  )
+      def mms(from:, media_urls:, text:, to:, options: nil, request_options: nil)
+        Async do
+          response = @request_client.conn.post do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["PINNACLE-API-KEY"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers = {
+          **(req.headers || {}),
+          **@request_client.get_headers,
+          **(request_options&.additional_headers || {})
+            }.compact
+            unless request_options.nil? || request_options&.additional_query_parameters.nil?
+              req.params = { **(request_options&.additional_query_parameters || {}) }.compact
+            end
+            req.body = {
+              **(request_options&.additional_body_parameters || {}),
+              from: from,
+              mediaUrls: media_urls,
+              options: options,
+              text: text,
+              to: to
+            }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/messages/send/mms"
+          end
+          Pinnacle::Messages::Send::Types::SendMmsResponse.from_json(json_object: response.body)
+        end
+      end
+
+      # Send a RCS message immediately or schedule it for future delivery. <br>
+      #  Requires an active RCS agent and recipient devices that support RCS Business
+      #  Messaging.
+      #
+      # @param request [Pinnacle::Types::RcsText, Pinnacle::Types::RcsMedia, Pinnacle::Types::RcsCard]
+      # @param request_options [Pinnacle::RequestOptions]
+      # @return [Pinnacle::Types::SentRcsDetails, Pinnacle::Types::ScheduledMessaage]
+      # @example
+      #  api = Pinnacle::Client.new(
+      #    base_url: "https://api.example.com",
+      #    environment: Pinnacle::Environment::DEFAULT,
+      #    api_key: "YOUR_API_KEY"
+      #  )
+      #  api.messages.send.rcs(request: { quick_replies: , text: "text", from: "from", to: "to" })
+      def rcs(request:, request_options: nil)
+        Async do
+          response = @request_client.conn.post do |req|
+            req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+            req.headers["PINNACLE-API-KEY"] = request_options.api_key unless request_options&.api_key.nil?
+            req.headers = {
+          **(req.headers || {}),
+          **@request_client.get_headers,
+          **(request_options&.additional_headers || {})
+            }.compact
+            unless request_options.nil? || request_options&.additional_query_parameters.nil?
+              req.params = { **(request_options&.additional_query_parameters || {}) }.compact
+            end
+            req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+            req.url "#{@request_client.get_url(request_options: request_options)}/messages/send/rcs"
+          end
+          Pinnacle::Messages::Send::Types::SendRcsResponse.from_json(json_object: response.body)
+        end
+      end
+    end
+  end
+end

data/lib/rcs/messages/send/types/send_mms_response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../types/sent_mms_details"
+require_relative "../../../types/scheduled_messaage"
+
+module Pinnacle
+  module Messages
+    module Send
+      module Types
+        class SendMmsResponse
+          # Deserialize a JSON object to an instance of SendMmsResponse
+          #
+          # @param json_object [String]
+          # @return [Pinnacle::Messages::Send::Types::SendMmsResponse]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            begin
+              Pinnacle::Types::SentMmsDetails.validate_raw(obj: struct)
+              return Pinnacle::Types::SentMmsDetails.from_json(json_object: struct) unless struct.nil?
+
+              return nil
+            rescue StandardError
+              # noop
+            end
+            begin
+              Pinnacle::Types::ScheduledMessaage.validate_raw(obj: struct)
+              return Pinnacle::Types::ScheduledMessaage.from_json(json_object: struct) unless struct.nil?
+
+              return nil
+            rescue StandardError
+              # noop
+            end
+            struct
+          end
+
+          # Leveraged for Union-type generation, validate_raw attempts to parse the given
+          #  hash and check each fields type against the current object's property
+          #  definitions.
+          #
+          # @param obj [Object]
+          # @return [Void]
+          def self.validate_raw(obj:)
+            begin
+              return Pinnacle::Types::SentMmsDetails.validate_raw(obj: obj)
+            rescue StandardError
+              # noop
+            end
+            begin
+              return Pinnacle::Types::ScheduledMessaage.validate_raw(obj: obj)
+            rescue StandardError
+              # noop
+            end
+            raise("Passed value matched no type within the union, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcs/messages/send/types/send_mms_schema_options.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "../../../types/message_schedule"
+require_relative "../../../types/tracking"
+require "ostruct"
+require "json"
+
+module Pinnacle
+  module Messages
+    module Send
+      module Types
+        # Control how your MMS is processed and delivered.
+        class SendMmsSchemaOptions
+          # @return [Boolean] Allow splitting large content into multiple MMS messages if size limits are
+          #  exceeded. <br>
+          #  If `false`, MMS over the limit will throw an error and won't be sent.
+          attr_reader :multiple_messages
+          # @return [Pinnacle::Types::MessageSchedule]
+          attr_reader :schedule
+          # @return [Pinnacle::Types::Tracking]
+          attr_reader :tracking
+          # @return [Boolean] Set to true to check this message and throw an error when validation fails. <br>
+          #  If errors occur, the message is not sent. Otherwise message is sent after
+          #  validation.
+          attr_reader :validate
+          # @return [OpenStruct] Additional properties unmapped to the current class definition
+          attr_reader :additional_properties
+          # @return [Object]
+          attr_reader :_field_set
+          protected :_field_set
+
+          OMIT = Object.new
+
+          # @param multiple_messages [Boolean] Allow splitting large content into multiple MMS messages if size limits are
+          #  exceeded. <br>
+          #  If `false`, MMS over the limit will throw an error and won't be sent.
+          # @param schedule [Pinnacle::Types::MessageSchedule]
+          # @param tracking [Pinnacle::Types::Tracking]
+          # @param validate [Boolean] Set to true to check this message and throw an error when validation fails. <br>
+          #  If errors occur, the message is not sent. Otherwise message is sent after
+          #  validation.
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [Pinnacle::Messages::Send::Types::SendMmsSchemaOptions]
+          def initialize(multiple_messages:, validate:, schedule: OMIT, tracking: OMIT, additional_properties: nil)
+            @multiple_messages = multiple_messages
+            @schedule = schedule if schedule != OMIT
+            @tracking = tracking if tracking != OMIT
+            @validate = validate
+            @additional_properties = additional_properties
+            @_field_set = {
+              "multiple_messages": multiple_messages,
+              "schedule": schedule,
+              "tracking": tracking,
+              "validate": validate
+            }.reject do |_k, v|
+              v == OMIT
+            end
+          end
+
+          # Deserialize a JSON object to an instance of SendMmsSchemaOptions
+          #
+          # @param json_object [String]
+          # @return [Pinnacle::Messages::Send::Types::SendMmsSchemaOptions]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            parsed_json = JSON.parse(json_object)
+            multiple_messages = parsed_json["multiple_messages"]
+            if parsed_json["schedule"].nil?
+              schedule = nil
+            else
+              schedule = parsed_json["schedule"].to_json
+              schedule = Pinnacle::Types::MessageSchedule.from_json(json_object: schedule)
+            end
+            tracking = parsed_json["tracking"]
+            validate = parsed_json["validate"]
+            new(
+              multiple_messages: multiple_messages,
+              schedule: schedule,
+              tracking: tracking,
+              validate: validate,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of SendMmsSchemaOptions to a JSON object
+          #
+          # @return [String]
+          def to_json(*_args)
+            @_field_set&.to_json
+          end
+
+          # Leveraged for Union-type generation, validate_raw attempts to parse the given
+          #  hash and check each fields type against the current object's property
+          #  definitions.
+          #
+          # @param obj [Object]
+          # @return [Void]
+          def self.validate_raw(obj:)
+            obj.multiple_messages.is_a?(Boolean) != false || raise("Passed value for field obj.multiple_messages is not the expected type, validation failed.")
+            obj.schedule.nil? || Pinnacle::Types::MessageSchedule.validate_raw(obj: obj.schedule)
+            obj.tracking&.is_a?(Pinnacle::Types::Tracking) != false || raise("Passed value for field obj.tracking is not the expected type, validation failed.")
+            obj.validate.is_a?(Boolean) != false || raise("Passed value for field obj.validate is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcs/messages/send/types/send_rcs_response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../types/sent_rcs_details"
+require_relative "../../../types/scheduled_messaage"
+
+module Pinnacle
+  module Messages
+    module Send
+      module Types
+        class SendRcsResponse
+          # Deserialize a JSON object to an instance of SendRcsResponse
+          #
+          # @param json_object [String]
+          # @return [Pinnacle::Messages::Send::Types::SendRcsResponse]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            begin
+              Pinnacle::Types::SentRcsDetails.validate_raw(obj: struct)
+              return Pinnacle::Types::SentRcsDetails.from_json(json_object: struct) unless struct.nil?
+
+              return nil
+            rescue StandardError
+              # noop
+            end
+            begin
+              Pinnacle::Types::ScheduledMessaage.validate_raw(obj: struct)
+              return Pinnacle::Types::ScheduledMessaage.from_json(json_object: struct) unless struct.nil?
+
+              return nil
+            rescue StandardError
+              # noop
+            end
+            struct
+          end
+
+          # Leveraged for Union-type generation, validate_raw attempts to parse the given
+          #  hash and check each fields type against the current object's property
+          #  definitions.
+          #
+          # @param obj [Object]
+          # @return [Void]
+          def self.validate_raw(obj:)
+            begin
+              return Pinnacle::Types::SentRcsDetails.validate_raw(obj: obj)
+            rescue StandardError
+              # noop
+            end
+            begin
+              return Pinnacle::Types::ScheduledMessaage.validate_raw(obj: obj)
+            rescue StandardError
+              # noop
+            end
+            raise("Passed value matched no type within the union, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcs/messages/send/types/send_sms_response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../types/sent_sms_details"
+require_relative "../../../types/scheduled_messaage"
+
+module Pinnacle
+  module Messages
+    module Send
+      module Types
+        class SendSmsResponse
+          # Deserialize a JSON object to an instance of SendSmsResponse
+          #
+          # @param json_object [String]
+          # @return [Pinnacle::Messages::Send::Types::SendSmsResponse]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            begin
+              Pinnacle::Types::SentSmsDetails.validate_raw(obj: struct)
+              return Pinnacle::Types::SentSmsDetails.from_json(json_object: struct) unless struct.nil?
+
+              return nil
+            rescue StandardError
+              # noop
+            end
+            begin
+              Pinnacle::Types::ScheduledMessaage.validate_raw(obj: struct)
+              return Pinnacle::Types::ScheduledMessaage.from_json(json_object: struct) unless struct.nil?
+
+              return nil
+            rescue StandardError
+              # noop
+            end
+            struct
+          end
+
+          # Leveraged for Union-type generation, validate_raw attempts to parse the given
+          #  hash and check each fields type against the current object's property
+          #  definitions.
+          #
+          # @param obj [Object]
+          # @return [Void]
+          def self.validate_raw(obj:)
+            begin
+              return Pinnacle::Types::SentSmsDetails.validate_raw(obj: obj)
+            rescue StandardError
+              # noop
+            end
+            begin
+              return Pinnacle::Types::ScheduledMessaage.validate_raw(obj: obj)
+            rescue StandardError
+              # noop
+            end
+            raise("Passed value matched no type within the union, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcs/messages/send/types/send_sms_schema_options.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../../../types/message_schedule"
+require_relative "../../../types/tracking"
+require "ostruct"
+require "json"
+
+module Pinnacle
+  module Messages
+    module Send
+      module Types
+        # Additional settings to customize SMS delivery.
+        class SendSmsSchemaOptions
+          # @return [Pinnacle::Types::MessageSchedule]
+          attr_reader :schedule
+          # @return [Pinnacle::Types::Tracking]
+          attr_reader :tracking
+          # @return [OpenStruct] Additional properties unmapped to the current class definition
+          attr_reader :additional_properties
+          # @return [Object]
+          attr_reader :_field_set
+          protected :_field_set
+
+          OMIT = Object.new
+
+          # @param schedule [Pinnacle::Types::MessageSchedule]
+          # @param tracking [Pinnacle::Types::Tracking]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [Pinnacle::Messages::Send::Types::SendSmsSchemaOptions]
+          def initialize(schedule: OMIT, tracking: OMIT, additional_properties: nil)
+            @schedule = schedule if schedule != OMIT
+            @tracking = tracking if tracking != OMIT
+            @additional_properties = additional_properties
+            @_field_set = { "schedule": schedule, "tracking": tracking }.reject do |_k, v|
+              v == OMIT
+            end
+          end
+
+          # Deserialize a JSON object to an instance of SendSmsSchemaOptions
+          #
+          # @param json_object [String]
+          # @return [Pinnacle::Messages::Send::Types::SendSmsSchemaOptions]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            parsed_json = JSON.parse(json_object)
+            if parsed_json["schedule"].nil?
+              schedule = nil
+            else
+              schedule = parsed_json["schedule"].to_json
+              schedule = Pinnacle::Types::MessageSchedule.from_json(json_object: schedule)
+            end
+            tracking = parsed_json["tracking"]
+            new(
+              schedule: schedule,
+              tracking: tracking,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of SendSmsSchemaOptions to a JSON object
+          #
+          # @return [String]
+          def to_json(*_args)
+            @_field_set&.to_json
+          end
+
+          # Leveraged for Union-type generation, validate_raw attempts to parse the given
+          #  hash and check each fields type against the current object's property
+          #  definitions.
+          #
+          # @param obj [Object]
+          # @return [Void]
+          def self.validate_raw(obj:)
+            obj.schedule.nil? || Pinnacle::Types::MessageSchedule.validate_raw(obj: obj.schedule)
+            obj.tracking&.is_a?(Pinnacle::Types::Tracking) != false || raise("Passed value for field obj.tracking is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end