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

data/rbi/moonbase/models/activity_program_message_bounced.rbi

@@ -0,0 +1,105 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageBounced < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageBounced,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_bounced`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # The type of bounce (e.g., `Permanent` for hard bounces, `Temporary` for soft
+      # bounces).
+      sig { returns(T.nilable(String)) }
+      attr_reader :bounce_type
+
+      sig { params(bounce_type: String).void }
+      attr_writer :bounce_type
+
+      # List of email addresses that bounced.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :bounced_recipient_emails
+
+      sig { params(bounced_recipient_emails: T::Array[String]).void }
+      attr_writer :bounced_recipient_emails
+
+      # Represents an event that occurs when a `ProgramMessage` bounces.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          bounce_type: String,
+          bounced_recipient_emails: T::Array[String],
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # The type of bounce (e.g., `Permanent` for hard bounces, `Temporary` for soft
+        # bounces).
+        bounce_type: nil,
+        # List of email addresses that bounced.
+        bounced_recipient_emails: nil,
+        # The type of activity. Always `activity/program_message_bounced`.
+        type: :"activity/program_message_bounced"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol,
+            bounce_type: String,
+            bounced_recipient_emails: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_program_message_clicked.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageClicked < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageClicked,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_clicked`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # The text of the link that was clicked.
+      sig { returns(T.nilable(String)) }
+      attr_reader :link_text
+
+      sig { params(link_text: String).void }
+      attr_writer :link_text
+
+      # The URL of the link that was clicked.
+      sig { returns(T.nilable(String)) }
+      attr_reader :link_url_unsafe
+
+      sig { params(link_url_unsafe: String).void }
+      attr_writer :link_url_unsafe
+
+      # Represents an event that occurs when a recipient clicks a tracked link in a
+      # `ProgramMessage`.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          link_text: String,
+          link_url_unsafe: String,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # The text of the link that was clicked.
+        link_text: nil,
+        # The URL of the link that was clicked.
+        link_url_unsafe: nil,
+        # The type of activity. Always `activity/program_message_clicked`.
+        type: :"activity/program_message_clicked"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol,
+            link_text: String,
+            link_url_unsafe: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_program_message_complained.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageComplained < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageComplained,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_complained`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Represents an event that occurs when a recipient marks a `ProgramMessage` as
+      # spam.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # The type of activity. Always `activity/program_message_complained`.
+        type: :"activity/program_message_complained"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_program_message_failed.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageFailed < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageFailed,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_failed`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # A code indicating the reason for the failure (e.g., `message_contained_virus`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :reason_code
+
+      sig { params(reason_code: String).void }
+      attr_writer :reason_code
+
+      # Represents an event that occurs when a `ProgramMessage` fails to be delivered
+      # for a technical reason.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          reason_code: String,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # A code indicating the reason for the failure (e.g., `message_contained_virus`).
+        reason_code: nil,
+        # The type of activity. Always `activity/program_message_failed`.
+        type: :"activity/program_message_failed"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol,
+            reason_code: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_program_message_opened.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageOpened < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageOpened,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_opened`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Represents an event that occurs when a recipient opens a `ProgramMessage`.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # The type of activity. Always `activity/program_message_opened`.
+        type: :"activity/program_message_opened"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_program_message_sent.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageSent < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageSent,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_sent`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # List of email addresses the message was sent to.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :recipient_emails
+
+      sig { params(recipient_emails: T::Array[String]).void }
+      attr_writer :recipient_emails
+
+      # Represents an event that occurs when a `ProgramMessage` is successfully sent.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          recipient_emails: T::Array[String],
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # List of email addresses the message was sent to.
+        recipient_emails: nil,
+        # The type of activity. Always `activity/program_message_sent`.
+        type: :"activity/program_message_sent"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol,
+            recipient_emails: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/moonbase/models/activity_program_message_shielded.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Moonbase
+  module Models
+    class ActivityProgramMessageShielded < Moonbase::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Moonbase::ActivityProgramMessageShielded,
+            Moonbase::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+      sig { returns(Time) }
+      attr_accessor :occurred_at
+
+      # A lightweight reference to another resource.
+      sig { returns(T.nilable(Moonbase::Pointer)) }
+      attr_reader :program_message
+
+      sig { params(program_message: T.nilable(Moonbase::Pointer::OrHash)).void }
+      attr_writer :program_message
+
+      # A reference to an `Item` within a specific `Collection`, providing the context
+      # needed to locate the item.
+      sig { returns(T.nilable(Moonbase::ItemPointer)) }
+      attr_reader :recipient
+
+      sig { params(recipient: T.nilable(Moonbase::ItemPointer::OrHash)).void }
+      attr_writer :recipient
+
+      # The type of activity. Always `activity/program_message_shielded`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # A code indicating why the message was shielded (e.g.,
+      # `person_previously_unsubscribed`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :reason_code
+
+      sig { params(reason_code: String).void }
+      attr_writer :reason_code
+
+      # Represents an event that occurs when a `ProgramMessage` is prevented from being
+      # sent by a delivery protection rule.
+      sig do
+        params(
+          id: String,
+          occurred_at: Time,
+          program_message: T.nilable(Moonbase::Pointer::OrHash),
+          recipient: T.nilable(Moonbase::ItemPointer::OrHash),
+          reason_code: String,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the object.
+        id:,
+        # The time at which the event occurred, as an ISO 8601 timestamp in UTC.
+        occurred_at:,
+        # A lightweight reference to another resource.
+        program_message:,
+        # A reference to an `Item` within a specific `Collection`, providing the context
+        # needed to locate the item.
+        recipient:,
+        # A code indicating why the message was shielded (e.g.,
+        # `person_previously_unsubscribed`).
+        reason_code: nil,
+        # The type of activity. Always `activity/program_message_shielded`.
+        type: :"activity/program_message_shielded"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            occurred_at: Time,
+            program_message: T.nilable(Moonbase::Pointer),
+            recipient: T.nilable(Moonbase::ItemPointer),
+            type: Symbol,
+            reason_code: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end