trycourier 4.3.0 → 4.5.0

data/rbi/trycourier/models/filter_config.rbi

@@ -2,92 +2,17 @@
 
 module Trycourier
   module Models
-    class FilterConfig < Trycourier::Internal::Type::BaseModel
-      OrHash =
+    # A single filter to use for filtering
+    module FilterConfig
+      extend Trycourier::Internal::Type::Union
+
+      Variants =
         T.type_alias do
-          T.any(Trycourier::FilterConfig, Trycourier::Internal::AnyHash)
+          T.any(Trycourier::SingleFilterConfig, Trycourier::NestedFilterConfig)
         end
 
-      # The operator to use for filtering
-      sig { returns(Trycourier::FilterConfig::Operator::OrSymbol) }
-      attr_accessor :operator
-
-      # The attribe name from profile whose value will be operated against the filter
-      # value
-      sig { returns(String) }
-      attr_accessor :path
-
-      # The value to use for filtering
-      sig { returns(String) }
-      attr_accessor :value
-
-      sig do
-        params(
-          operator: Trycourier::FilterConfig::Operator::OrSymbol,
-          path: String,
-          value: String
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # The operator to use for filtering
-        operator:,
-        # The attribe name from profile whose value will be operated against the filter
-        # value
-        path:,
-        # The value to use for filtering
-        value:
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            operator: Trycourier::FilterConfig::Operator::OrSymbol,
-            path: String,
-            value: String
-          }
-        )
-      end
-      def to_hash
-      end
-
-      # The operator to use for filtering
-      module Operator
-        extend Trycourier::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, Trycourier::FilterConfig::Operator) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        ENDS_WITH =
-          T.let(:ENDS_WITH, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        EQ = T.let(:EQ, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        EXISTS =
-          T.let(:EXISTS, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        GT = T.let(:GT, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        GTE = T.let(:GTE, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        INCLUDES =
-          T.let(:INCLUDES, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        IS_AFTER =
-          T.let(:IS_AFTER, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        IS_BEFORE =
-          T.let(:IS_BEFORE, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        LT = T.let(:LT, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        LTE = T.let(:LTE, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        NEQ = T.let(:NEQ, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        OMIT = T.let(:OMIT, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        STARTS_WITH =
-          T.let(:STARTS_WITH, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        AND = T.let(:AND, Trycourier::FilterConfig::Operator::TaggedSymbol)
-        OR = T.let(:OR, Trycourier::FilterConfig::Operator::TaggedSymbol)
-
-        sig do
-          override.returns(
-            T::Array[Trycourier::FilterConfig::Operator::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
+      sig { override.returns(T::Array[Trycourier::FilterConfig::Variants]) }
+      def self.variants
       end
     end
   end

data/rbi/trycourier/models/inbound_bulk_message.rbi

@@ -2,187 +2,131 @@
 
 module Trycourier
   module Models
-    module InboundBulkMessage
-      extend Trycourier::Internal::Type::Union
-
-      Variants =
+    class InboundBulkMessage < Trycourier::Internal::Type::BaseModel
+      OrHash =
         T.type_alias do
-          T.any(
-            Trycourier::InboundBulkMessage::InboundBulkTemplateMessage,
-            Trycourier::InboundBulkMessage::InboundBulkContentMessage
-          )
-        end
-
-      class InboundBulkTemplateMessage < Trycourier::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Trycourier::InboundBulkMessage::InboundBulkTemplateMessage,
-              Trycourier::Internal::AnyHash
-            )
-          end
-
-        sig { returns(String) }
-        attr_accessor :template
-
-        sig { returns(T.nilable(String)) }
-        attr_accessor :brand
-
-        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-        attr_accessor :data
-
-        sig { returns(T.nilable(String)) }
-        attr_accessor :event
-
-        sig { returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]])) }
-        attr_accessor :locale
-
-        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-        attr_accessor :override
-
-        sig do
-          params(
-            template: String,
-            brand: T.nilable(String),
-            data: T.nilable(T::Hash[Symbol, T.anything]),
-            event: T.nilable(String),
-            locale: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]]),
-            override: T.nilable(T::Hash[Symbol, T.anything])
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          template:,
-          brand: nil,
-          data: nil,
-          event: nil,
-          locale: nil,
-          override: nil
-        )
+          T.any(Trycourier::InboundBulkMessage, Trycourier::Internal::AnyHash)
         end
 
-        sig do
-          override.returns(
-            {
-              template: String,
-              brand: T.nilable(String),
-              data: T.nilable(T::Hash[Symbol, T.anything]),
-              event: T.nilable(String),
-              locale: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]]),
-              override: T.nilable(T::Hash[Symbol, T.anything])
-            }
-          )
-        end
-        def to_hash
-        end
-      end
+      # Event ID or Notification ID (required). Can be either a Notification ID (e.g.,
+      # "FRH3QXM9E34W4RKP7MRC8NZ1T8V8") or a custom Event ID (e.g., "welcome-email")
+      # mapped to a notification.
+      sig { returns(String) }
+      attr_accessor :event
 
-      class InboundBulkContentMessage < Trycourier::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Trycourier::InboundBulkMessage::InboundBulkContentMessage,
-              Trycourier::Internal::AnyHash
-            )
-          end
+      sig { returns(T.nilable(String)) }
+      attr_accessor :brand
 
-        # Syntactic sugar to provide a fast shorthand for Courier Elemental Blocks.
-        sig do
-          returns(
+      # Elemental content (optional, for V2 format). When provided, this will be used
+      # instead of the notification associated with the `event` field.
+      sig do
+        returns(
+          T.nilable(
             T.any(
               Trycourier::ElementalContentSugar,
               Trycourier::ElementalContent
             )
           )
-        end
-        attr_accessor :content
-
-        sig { returns(T.nilable(String)) }
-        attr_accessor :brand
+        )
+      end
+      attr_accessor :content
 
-        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-        attr_accessor :data
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
 
-        sig { returns(T.nilable(String)) }
-        attr_accessor :event
+      sig { returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]])) }
+      attr_accessor :locale
 
-        sig { returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]])) }
-        attr_accessor :locale
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :override
 
-        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-        attr_accessor :override
+      # Notification ID or template ID (optional, for V2 format). When provided, this
+      # will be used instead of the notification associated with the `event` field.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :template
 
-        sig do
-          params(
-            content:
+      # Bulk message definition. Supports two formats:
+      #
+      # - V1 format: Requires `event` field (event ID or notification ID)
+      # - V2 format: Optionally use `template` (notification ID) or `content` (Elemental
+      #   content) in addition to `event`
+      sig do
+        params(
+          event: String,
+          brand: T.nilable(String),
+          content:
+            T.nilable(
               T.any(
                 Trycourier::ElementalContentSugar::OrHash,
                 Trycourier::ElementalContent::OrHash
-              ),
+              )
+            ),
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          locale: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]]),
+          override: T.nilable(T::Hash[Symbol, T.anything]),
+          template: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Event ID or Notification ID (required). Can be either a Notification ID (e.g.,
+        # "FRH3QXM9E34W4RKP7MRC8NZ1T8V8") or a custom Event ID (e.g., "welcome-email")
+        # mapped to a notification.
+        event:,
+        brand: nil,
+        # Elemental content (optional, for V2 format). When provided, this will be used
+        # instead of the notification associated with the `event` field.
+        content: nil,
+        data: nil,
+        locale: nil,
+        override: nil,
+        # Notification ID or template ID (optional, for V2 format). When provided, this
+        # will be used instead of the notification associated with the `event` field.
+        template: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            event: String,
             brand: T.nilable(String),
+            content:
+              T.nilable(
+                T.any(
+                  Trycourier::ElementalContentSugar,
+                  Trycourier::ElementalContent
+                )
+              ),
             data: T.nilable(T::Hash[Symbol, T.anything]),
-            event: T.nilable(String),
             locale: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]]),
-            override: T.nilable(T::Hash[Symbol, T.anything])
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Syntactic sugar to provide a fast shorthand for Courier Elemental Blocks.
-          content:,
-          brand: nil,
-          data: nil,
-          event: nil,
-          locale: nil,
-          override: nil
+            override: T.nilable(T::Hash[Symbol, T.anything]),
+            template: T.nilable(String)
+          }
         )
-        end
+      end
+      def to_hash
+      end
+
+      # Elemental content (optional, for V2 format). When provided, this will be used
+      # instead of the notification associated with the `event` field.
+      module Content
+        extend Trycourier::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Trycourier::ElementalContentSugar,
+              Trycourier::ElementalContent
+            )
+          end
 
         sig do
           override.returns(
-            {
-              content:
-                T.any(
-                  Trycourier::ElementalContentSugar,
-                  Trycourier::ElementalContent
-                ),
-              brand: T.nilable(String),
-              data: T.nilable(T::Hash[Symbol, T.anything]),
-              event: T.nilable(String),
-              locale: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T.anything]]),
-              override: T.nilable(T::Hash[Symbol, T.anything])
-            }
+            T::Array[Trycourier::InboundBulkMessage::Content::Variants]
           )
         end
-        def to_hash
+        def self.variants
         end
-
-        # Syntactic sugar to provide a fast shorthand for Courier Elemental Blocks.
-        module Content
-          extend Trycourier::Internal::Type::Union
-
-          Variants =
-            T.type_alias do
-              T.any(
-                Trycourier::ElementalContentSugar,
-                Trycourier::ElementalContent
-              )
-            end
-
-          sig do
-            override.returns(
-              T::Array[
-                Trycourier::InboundBulkMessage::InboundBulkContentMessage::Content::Variants
-              ]
-            )
-          end
-          def self.variants
-          end
-        end
-      end
-
-      sig do
-        override.returns(T::Array[Trycourier::InboundBulkMessage::Variants])
-      end
-      def self.variants
       end
     end
   end

data/rbi/trycourier/models/inbound_bulk_message_user.rbi

@@ -11,6 +11,7 @@ module Trycourier
           )
         end
 
+      # User-specific data that will be merged with message.data
       sig { returns(T.nilable(T.anything)) }
       attr_reader :data
 
@@ -27,15 +28,19 @@ module Trycourier
       end
       attr_writer :preferences
 
-      sig { returns(T.nilable(T.anything)) }
-      attr_reader :profile
-
-      sig { params(profile: T.anything).void }
-      attr_writer :profile
+      # User profile information. For email-based bulk jobs, `profile.email` is required
+      # for provider routing to determine if the message can be delivered. The email
+      # address should be provided here rather than in `to.email`.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :profile
 
+      # User ID (legacy field, use profile or to.user_id instead)
       sig { returns(T.nilable(String)) }
       attr_accessor :recipient
 
+      # Optional recipient information. Note: For email provider routing, use
+      # `profile.email` instead of `to.email`. The `to` field is primarily used for
+      # recipient identification and data merging.
       sig { returns(T.nilable(Trycourier::UserRecipient)) }
       attr_reader :to
 
@@ -46,16 +51,24 @@ module Trycourier
         params(
           data: T.anything,
           preferences: T.nilable(Trycourier::RecipientPreferences::OrHash),
-          profile: T.anything,
+          profile: T.nilable(T::Hash[Symbol, T.anything]),
           recipient: T.nilable(String),
           to: T.nilable(Trycourier::UserRecipient::OrHash)
         ).returns(T.attached_class)
       end
       def self.new(
+        # User-specific data that will be merged with message.data
         data: nil,
         preferences: nil,
+        # User profile information. For email-based bulk jobs, `profile.email` is required
+        # for provider routing to determine if the message can be delivered. The email
+        # address should be provided here rather than in `to.email`.
         profile: nil,
+        # User ID (legacy field, use profile or to.user_id instead)
         recipient: nil,
+        # Optional recipient information. Note: For email provider routing, use
+        # `profile.email` instead of `to.email`. The `to` field is primarily used for
+        # recipient identification and data merging.
         to: nil
       )
       end
@@ -65,7 +78,7 @@ module Trycourier
           {
             data: T.anything,
             preferences: T.nilable(Trycourier::RecipientPreferences),
-            profile: T.anything,
+            profile: T.nilable(T::Hash[Symbol, T.anything]),
             recipient: T.nilable(String),
             to: T.nilable(Trycourier::UserRecipient)
           }

data/rbi/trycourier/models/intercom.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Trycourier
+  module Models
+    class Intercom < Trycourier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Trycourier::Intercom, Trycourier::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :from
+
+      sig { returns(Trycourier::IntercomRecipient) }
+      attr_reader :to
+
+      sig { params(to: Trycourier::IntercomRecipient::OrHash).void }
+      attr_writer :to
+
+      sig do
+        params(from: String, to: Trycourier::IntercomRecipient::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(from:, to:)
+      end
+
+      sig do
+        override.returns({ from: String, to: Trycourier::IntercomRecipient })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/trycourier/models/intercom_recipient.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Trycourier
+  module Models
+    class IntercomRecipient < Trycourier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Trycourier::IntercomRecipient, Trycourier::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { params(id: String).returns(T.attached_class) }
+      def self.new(id:)
+      end
+
+      sig { override.returns({ id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/trycourier/models/list_filter.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Trycourier
+  module Models
+    class ListFilter < Trycourier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Trycourier::ListFilter, Trycourier::Internal::AnyHash)
+        end
+
+      # Send to users only if they are member of the account
+      sig { returns(Trycourier::ListFilter::Operator::OrSymbol) }
+      attr_accessor :operator
+
+      sig { returns(Trycourier::ListFilter::Path::OrSymbol) }
+      attr_accessor :path
+
+      sig { returns(String) }
+      attr_accessor :value
+
+      sig do
+        params(
+          operator: Trycourier::ListFilter::Operator::OrSymbol,
+          path: Trycourier::ListFilter::Path::OrSymbol,
+          value: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Send to users only if they are member of the account
+        operator:,
+        path:,
+        value:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            operator: Trycourier::ListFilter::Operator::OrSymbol,
+            path: Trycourier::ListFilter::Path::OrSymbol,
+            value: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Send to users only if they are member of the account
+      module Operator
+        extend Trycourier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Trycourier::ListFilter::Operator) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MEMBER_OF =
+          T.let(:MEMBER_OF, Trycourier::ListFilter::Operator::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Trycourier::ListFilter::Operator::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Path
+        extend Trycourier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Trycourier::ListFilter::Path) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACCOUNT_ID =
+          T.let(:account_id, Trycourier::ListFilter::Path::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Trycourier::ListFilter::Path::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/trycourier/models/list_pattern_recipient.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Trycourier
+  module Models
+    class ListPatternRecipient < Trycourier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Trycourier::ListPatternRecipient, Trycourier::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :list_pattern
+
+      # Send to users in lists matching a pattern
+      sig do
+        params(
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          list_pattern: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, list_pattern: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(T::Hash[Symbol, T.anything]),
+            list_pattern: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/trycourier/models/list_recipient.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Trycourier
+  module Models
+    class ListRecipient < Trycourier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Trycourier::ListRecipient, Trycourier::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      sig { returns(T.nilable(T::Array[Trycourier::ListFilter])) }
+      attr_accessor :filters
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :list_id
+
+      # Send to all users in a specific list
+      sig do
+        params(
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          filters: T.nilable(T::Array[Trycourier::ListFilter::OrHash]),
+          list_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, filters: nil, list_id: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(T::Hash[Symbol, T.anything]),
+            filters: T.nilable(T::Array[Trycourier::ListFilter]),
+            list_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end