moonbase-sdk 0.1.0.pre.alpha.2 → 0.1.0.pre.alpha.4

data/rbi/moonbase/models/program.rbi

@@ -10,17 +10,23 @@ module Moonbase
       sig { returns(String) }
       attr_accessor :id
 
-      sig { returns(Moonbase::Program::Links) }
-      attr_reader :links
-
-      sig { params(links: Moonbase::Program::Links::OrHash).void }
-      attr_writer :links
+      # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
 
       # The current status of the program. Can be `draft`, `published`, `paused`, or
       # `archived`.
       sig { returns(Moonbase::Program::Status::TaggedSymbol) }
       attr_accessor :status
 
+      # `true` if link clicks are tracked for this program.
+      sig { returns(T::Boolean) }
+      attr_accessor :track_clicks
+
+      # `true` if email opens are tracked for this program.
+      sig { returns(T::Boolean) }
+      attr_accessor :track_opens
+
       # The sending trigger for the program. Can be `api` for transactional sends or
       # `broadcast` for scheduled sends.
       sig { returns(Moonbase::Program::Trigger::TaggedSymbol) }
@@ -30,7 +36,13 @@ module Moonbase
       sig { returns(Symbol) }
       attr_accessor :type
 
+      # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
       # A `ProgramActivityMetrics` object summarizing engagement for this program.
+      #
+      # **Note:** Only present when requested using the `include` query parameter.
       sig { returns(T.nilable(Moonbase::Program::ActivityMetrics)) }
       attr_reader :activity_metrics
 
@@ -41,13 +53,6 @@ module Moonbase
       end
       attr_writer :activity_metrics
 
-      # Time at which the object was created, as an RFC 3339 timestamp.
-      sig { returns(T.nilable(Time)) }
-      attr_reader :created_at
-
-      sig { params(created_at: Time).void }
-      attr_writer :created_at
-
       # The user-facing name of the program.
       sig { returns(T.nilable(String)) }
       attr_reader :display_name
@@ -56,87 +61,70 @@ module Moonbase
       attr_writer :display_name
 
       # The `ProgramTemplate` used for messages in this program.
+      #
+      # **Note:** Only present when requested using the `include` query parameter.
       sig { returns(T.nilable(Moonbase::ProgramTemplate)) }
       attr_reader :program_template
 
       sig { params(program_template: Moonbase::ProgramTemplate).void }
       attr_writer :program_template
 
-      # For `broadcast` programs, the time the program is scheduled to send, as an RFC
-      # 3339 timestamp.
+      # For `broadcast` programs, the time the program is scheduled to send, as an ISO
+      # 8601 timestamp in UTC.
       sig { returns(T.nilable(Time)) }
       attr_reader :scheduled_at
 
       sig { params(scheduled_at: Time).void }
       attr_writer :scheduled_at
 
-      # `true` if link clicks are tracked for this program.
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :track_clicks
-
-      sig { params(track_clicks: T::Boolean).void }
-      attr_writer :track_clicks
-
-      # `true` if email opens are tracked for this program.
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_reader :track_opens
-
-      sig { params(track_opens: T::Boolean).void }
-      attr_writer :track_opens
-
-      # Time at which the object was last updated, as an RFC 3339 timestamp.
-      sig { returns(T.nilable(Time)) }
-      attr_reader :updated_at
-
-      sig { params(updated_at: Time).void }
-      attr_writer :updated_at
-
       # The Program object represents an email campaign. It defines the sending behavior
       # and tracks engagement metrics.
       sig do
         params(
           id: String,
-          links: Moonbase::Program::Links::OrHash,
+          created_at: Time,
           status: Moonbase::Program::Status::OrSymbol,
+          track_clicks: T::Boolean,
+          track_opens: T::Boolean,
           trigger: Moonbase::Program::Trigger::OrSymbol,
+          updated_at: Time,
           activity_metrics: Moonbase::Program::ActivityMetrics::OrHash,
-          created_at: Time,
           display_name: String,
           program_template: Moonbase::ProgramTemplate,
           scheduled_at: Time,
-          track_clicks: T::Boolean,
-          track_opens: T::Boolean,
-          updated_at: Time,
           type: Symbol
         ).returns(T.attached_class)
       end
       def self.new(
         # Unique identifier for the object.
         id:,
-        links:,
+        # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+        created_at:,
         # The current status of the program. Can be `draft`, `published`, `paused`, or
         # `archived`.
         status:,
+        # `true` if link clicks are tracked for this program.
+        track_clicks:,
+        # `true` if email opens are tracked for this program.
+        track_opens:,
         # The sending trigger for the program. Can be `api` for transactional sends or
         # `broadcast` for scheduled sends.
         trigger:,
+        # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+        updated_at:,
         # A `ProgramActivityMetrics` object summarizing engagement for this program.
+        #
+        # **Note:** Only present when requested using the `include` query parameter.
         activity_metrics: nil,
-        # Time at which the object was created, as an RFC 3339 timestamp.
-        created_at: nil,
         # The user-facing name of the program.
         display_name: nil,
         # The `ProgramTemplate` used for messages in this program.
+        #
+        # **Note:** Only present when requested using the `include` query parameter.
         program_template: nil,
-        # For `broadcast` programs, the time the program is scheduled to send, as an RFC
-        # 3339 timestamp.
+        # For `broadcast` programs, the time the program is scheduled to send, as an ISO
+        # 8601 timestamp in UTC.
         scheduled_at: nil,
-        # `true` if link clicks are tracked for this program.
-        track_clicks: nil,
-        # `true` if email opens are tracked for this program.
-        track_opens: nil,
-        # Time at which the object was last updated, as an RFC 3339 timestamp.
-        updated_at: nil,
         # String representing the object’s type. Always `program` for this object.
         type: :program
       )
@@ -146,56 +134,23 @@ module Moonbase
         override.returns(
           {
             id: String,
-            links: Moonbase::Program::Links,
+            created_at: Time,
             status: Moonbase::Program::Status::TaggedSymbol,
+            track_clicks: T::Boolean,
+            track_opens: T::Boolean,
             trigger: Moonbase::Program::Trigger::TaggedSymbol,
             type: Symbol,
+            updated_at: Time,
             activity_metrics: Moonbase::Program::ActivityMetrics,
-            created_at: Time,
             display_name: String,
             program_template: Moonbase::ProgramTemplate,
-            scheduled_at: Time,
-            track_clicks: T::Boolean,
-            track_opens: T::Boolean,
-            updated_at: Time
+            scheduled_at: Time
           }
         )
       end
       def to_hash
       end
 
-      class Links < Moonbase::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Moonbase::Program::Links, Moonbase::Internal::AnyHash)
-          end
-
-        # A link to the `ProgramTemplate` for this program.
-        sig { returns(String) }
-        attr_accessor :program_template
-
-        # The canonical URL for this object.
-        sig { returns(String) }
-        attr_accessor :self_
-
-        sig do
-          params(program_template: String, self_: String).returns(
-            T.attached_class
-          )
-        end
-        def self.new(
-          # A link to the `ProgramTemplate` for this program.
-          program_template:,
-          # The canonical URL for this object.
-          self_:
-        )
-        end
-
-        sig { override.returns({ program_template: String, self_: String }) }
-        def to_hash
-        end
-      end
-
       # The current status of the program. Can be `draft`, `published`, `paused`, or
       # `archived`.
       module Status
@@ -245,62 +200,40 @@ module Moonbase
           end
 
         # The number of emails that could not be delivered.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :bounced
-
-        sig { params(bounced: Integer).void }
-        attr_writer :bounced
+        sig { returns(Integer) }
+        attr_accessor :bounced
 
         # The number of recipients who clicked at least one link.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :clicked
-
-        sig { params(clicked: Integer).void }
-        attr_writer :clicked
+        sig { returns(Integer) }
+        attr_accessor :clicked
 
         # The number of recipients who marked the email as spam.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :complained
-
-        sig { params(complained: Integer).void }
-        attr_writer :complained
+        sig { returns(Integer) }
+        attr_accessor :complained
 
         # The number of emails that failed to send due to a technical issue.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :failed
-
-        sig { params(failed: Integer).void }
-        attr_writer :failed
+        sig { returns(Integer) }
+        attr_accessor :failed
 
         # The number of recipients who opened the email.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :opened
-
-        sig { params(opened: Integer).void }
-        attr_writer :opened
+        sig { returns(Integer) }
+        attr_accessor :opened
 
         # The total number of emails successfully sent.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :sent
-
-        sig { params(sent: Integer).void }
-        attr_writer :sent
+        sig { returns(Integer) }
+        attr_accessor :sent
 
         # The number of emails blocked by delivery protection rules.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :shielded
-
-        sig { params(shielded: Integer).void }
-        attr_writer :shielded
+        sig { returns(Integer) }
+        attr_accessor :shielded
 
         # The number of recipients who unsubscribed.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :unsubscribed
-
-        sig { params(unsubscribed: Integer).void }
-        attr_writer :unsubscribed
+        sig { returns(Integer) }
+        attr_accessor :unsubscribed
 
         # A `ProgramActivityMetrics` object summarizing engagement for this program.
+        #
+        # **Note:** Only present when requested using the `include` query parameter.
         sig do
           params(
             bounced: Integer,
@@ -315,21 +248,21 @@ module Moonbase
         end
         def self.new(
           # The number of emails that could not be delivered.
-          bounced: nil,
+          bounced:,
           # The number of recipients who clicked at least one link.
-          clicked: nil,
+          clicked:,
           # The number of recipients who marked the email as spam.
-          complained: nil,
+          complained:,
           # The number of emails that failed to send due to a technical issue.
-          failed: nil,
+          failed:,
           # The number of recipients who opened the email.
-          opened: nil,
+          opened:,
           # The total number of emails successfully sent.
-          sent: nil,
+          sent:,
           # The number of emails blocked by delivery protection rules.
-          shielded: nil,
+          shielded:,
           # The number of recipients who unsubscribed.
-          unsubscribed: nil
+          unsubscribed:
         )
         end
 

data/rbi/moonbase/models/{program_message_create_response.rbi → program_message.rbi}

@@ -2,34 +2,21 @@
 
 module Moonbase
   module Models
-    class ProgramMessageCreateResponse < Moonbase::Internal::Type::BaseModel
+    class ProgramMessage < Moonbase::Internal::Type::BaseModel
       OrHash =
         T.type_alias do
-          T.any(
-            Moonbase::Models::ProgramMessageCreateResponse,
-            Moonbase::Internal::AnyHash
-          )
+          T.any(Moonbase::ProgramMessage, Moonbase::Internal::AnyHash)
         end
 
       # Unique identifier for the object.
       sig { returns(String) }
       attr_accessor :id
 
-      # Time at which the message was created and enqueued for sending, as an RFC 3339
-      # timestamp.
+      # Time at which the message was created and enqueued for sending, as an ISO 8601
+      # timestamp in UTC.
       sig { returns(Time) }
       attr_accessor :created_at
 
-      sig { returns(Moonbase::Models::ProgramMessageCreateResponse::Links) }
-      attr_reader :links
-
-      sig do
-        params(
-          links: Moonbase::Models::ProgramMessageCreateResponse::Links::OrHash
-        ).void
-      end
-      attr_writer :links
-
       # The `ProgramTemplate` used to generate this message.
       sig { returns(Moonbase::ProgramTemplate) }
       attr_reader :program_template
@@ -41,7 +28,7 @@ module Moonbase
       sig { returns(Symbol) }
       attr_accessor :type
 
-      # Time at which the object was last updated, as an RFC 3339 timestamp.
+      # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
       sig { returns(Time) }
       attr_accessor :updated_at
 
@@ -50,7 +37,6 @@ module Moonbase
         params(
           id: String,
           created_at: Time,
-          links: Moonbase::Models::ProgramMessageCreateResponse::Links::OrHash,
           program_template: Moonbase::ProgramTemplate::OrHash,
           updated_at: Time,
           type: Symbol
@@ -59,13 +45,12 @@ module Moonbase
       def self.new(
         # Unique identifier for the object.
         id:,
-        # Time at which the message was created and enqueued for sending, as an RFC 3339
-        # timestamp.
+        # Time at which the message was created and enqueued for sending, as an ISO 8601
+        # timestamp in UTC.
         created_at:,
-        links:,
         # The `ProgramTemplate` used to generate this message.
         program_template:,
-        # Time at which the object was last updated, as an RFC 3339 timestamp.
+        # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
         updated_at:,
         # String representing the object’s type. Always `program_message` for this object.
         type: :program_message
@@ -77,7 +62,6 @@ module Moonbase
           {
             id: String,
             created_at: Time,
-            links: Moonbase::Models::ProgramMessageCreateResponse::Links,
             program_template: Moonbase::ProgramTemplate,
             type: Symbol,
             updated_at: Time
@@ -86,31 +70,6 @@ module Moonbase
       end
       def to_hash
       end
-
-      class Links < Moonbase::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Moonbase::Models::ProgramMessageCreateResponse::Links,
-              Moonbase::Internal::AnyHash
-            )
-          end
-
-        # A link to the `ProgramTemplate` used.
-        sig { returns(String) }
-        attr_accessor :program_template
-
-        sig { params(program_template: String).returns(T.attached_class) }
-        def self.new(
-          # A link to the `ProgramTemplate` used.
-          program_template:
-        )
-        end
-
-        sig { override.returns({ program_template: String }) }
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/moonbase/models/{program_message_create_params.rbi → program_message_send_params.rbi}

@@ -2,26 +2,21 @@
 
 module Moonbase
   module Models
-    class ProgramMessageCreateParams < Moonbase::Internal::Type::BaseModel
+    class ProgramMessageSendParams < Moonbase::Internal::Type::BaseModel
       extend Moonbase::Internal::Type::RequestParameters::Converter
       include Moonbase::Internal::Type::RequestParameters
 
       OrHash =
         T.type_alias do
-          T.any(
-            Moonbase::ProgramMessageCreateParams,
-            Moonbase::Internal::AnyHash
-          )
+          T.any(Moonbase::ProgramMessageSendParams, Moonbase::Internal::AnyHash)
         end
 
       # The person to send the message to.
-      sig { returns(Moonbase::ProgramMessageCreateParams::Person) }
+      sig { returns(Moonbase::ProgramMessageSendParams::Person) }
       attr_reader :person
 
       sig do
-        params(
-          person: Moonbase::ProgramMessageCreateParams::Person::OrHash
-        ).void
+        params(person: Moonbase::ProgramMessageSendParams::Person::OrHash).void
       end
       attr_writer :person
 
@@ -38,7 +33,7 @@ module Moonbase
 
       sig do
         params(
-          person: Moonbase::ProgramMessageCreateParams::Person::OrHash,
+          person: Moonbase::ProgramMessageSendParams::Person::OrHash,
           program_template_id: String,
           custom_variables: T::Hash[Symbol, T.anything],
           request_options: Moonbase::RequestOptions::OrHash
@@ -58,7 +53,7 @@ module Moonbase
       sig do
         override.returns(
           {
-            person: Moonbase::ProgramMessageCreateParams::Person,
+            person: Moonbase::ProgramMessageSendParams::Person,
             program_template_id: String,
             custom_variables: T::Hash[Symbol, T.anything],
             request_options: Moonbase::RequestOptions
@@ -72,7 +67,7 @@ module Moonbase
         OrHash =
           T.type_alias do
             T.any(
-              Moonbase::ProgramMessageCreateParams::Person,
+              Moonbase::ProgramMessageSendParams::Person,
               Moonbase::Internal::AnyHash
             )
           end

data/rbi/moonbase/models/program_template.rbi

@@ -13,14 +13,15 @@ module Moonbase
       attr_accessor :id
 
       # The body content of the email, which can include Liquid variables.
-      sig { returns(String) }
-      attr_accessor :body
+      sig { returns(Moonbase::FormattedText) }
+      attr_reader :body
 
-      sig { returns(Moonbase::ProgramTemplate::Links) }
-      attr_reader :links
+      sig { params(body: Moonbase::FormattedText::OrHash).void }
+      attr_writer :body
 
-      sig { params(links: Moonbase::ProgramTemplate::Links::OrHash).void }
-      attr_writer :links
+      # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
 
       # The subject line of the email, which can include Liquid variables.
       sig { returns(String) }
@@ -31,38 +32,29 @@ module Moonbase
       sig { returns(Symbol) }
       attr_accessor :type
 
-      # Time at which the object was created, as an RFC 3339 timestamp.
-      sig { returns(T.nilable(Time)) }
-      attr_reader :created_at
-
-      sig { params(created_at: Time).void }
-      attr_writer :created_at
+      # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :updated_at
 
       # The `Program` that uses this template.
+      #
+      # **Note:** Only present when requested using the `include` query parameter.
       sig { returns(T.nilable(Moonbase::Program)) }
       attr_reader :program
 
       sig { params(program: Moonbase::Program).void }
       attr_writer :program
 
-      # Time at which the object was last updated, as an RFC 3339 timestamp.
-      sig { returns(T.nilable(Time)) }
-      attr_reader :updated_at
-
-      sig { params(updated_at: Time).void }
-      attr_writer :updated_at
-
       # The ProgramTemplate object defines the content of a message sent by a `Program`,
       # including support for Liquid templating.
       sig do
         params(
           id: String,
-          body: String,
-          links: Moonbase::ProgramTemplate::Links::OrHash,
-          subject: String,
+          body: Moonbase::FormattedText::OrHash,
           created_at: Time,
-          program: Moonbase::Program,
+          subject: String,
           updated_at: Time,
+          program: Moonbase::Program,
           type: Symbol
         ).returns(T.attached_class)
       end
@@ -71,15 +63,16 @@ module Moonbase
         id:,
         # The body content of the email, which can include Liquid variables.
         body:,
-        links:,
+        # Time at which the object was created, as an ISO 8601 timestamp in UTC.
+        created_at:,
         # The subject line of the email, which can include Liquid variables.
         subject:,
-        # Time at which the object was created, as an RFC 3339 timestamp.
-        created_at: nil,
+        # Time at which the object was last updated, as an ISO 8601 timestamp in UTC.
+        updated_at:,
         # The `Program` that uses this template.
+        #
+        # **Note:** Only present when requested using the `include` query parameter.
         program: nil,
-        # Time at which the object was last updated, as an RFC 3339 timestamp.
-        updated_at: nil,
         # String representing the object’s type. Always `program_template` for this
         # object.
         type: :program_template
@@ -90,49 +83,17 @@ module Moonbase
         override.returns(
           {
             id: String,
-            body: String,
-            links: Moonbase::ProgramTemplate::Links,
+            body: Moonbase::FormattedText,
+            created_at: Time,
             subject: String,
             type: Symbol,
-            created_at: Time,
-            program: Moonbase::Program,
-            updated_at: Time
+            updated_at: Time,
+            program: Moonbase::Program
           }
         )
       end
       def to_hash
       end
-
-      class Links < Moonbase::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Moonbase::ProgramTemplate::Links, Moonbase::Internal::AnyHash)
-          end
-
-        # The canonical URL for this object.
-        sig { returns(String) }
-        attr_accessor :self_
-
-        # A link to the `Program` using this template.
-        sig { returns(T.nilable(String)) }
-        attr_reader :program
-
-        sig { params(program: String).void }
-        attr_writer :program
-
-        sig { params(self_: String, program: String).returns(T.attached_class) }
-        def self.new(
-          # The canonical URL for this object.
-          self_:,
-          # A link to the `Program` using this template.
-          program: nil
-        )
-        end
-
-        sig { override.returns({ self_: String, program: String }) }
-        def to_hash
-        end
-      end
     end
   end
 end