trycourier 4.10.1 → 4.11.0

data/rbi/courier/models/journey_retrieve_params.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyRetrieveParams < Courier::Internal::Type::BaseModel
+      extend Courier::Internal::Type::RequestParameters::Converter
+      include Courier::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyRetrieveParams, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :template_id
+
+      # Version selector: `draft`, `published` (default), or `vN`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { params(version: String).void }
+      attr_writer :version
+
+      sig do
+        params(
+          template_id: String,
+          version: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        template_id:,
+        # Version selector: `draft`, `published` (default), or `vN`.
+        version: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            template_id: String,
+            version: String,
+            request_options: Courier::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_segment_trigger_node.rbi

@@ -0,0 +1,200 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneySegmentTriggerNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneySegmentTriggerNode, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(Courier::JourneySegmentTriggerNode::RequestType::OrSymbol) }
+      attr_accessor :request_type
+
+      sig { returns(Courier::JourneySegmentTriggerNode::TriggerType::OrSymbol) }
+      attr_accessor :trigger_type
+
+      sig { returns(Courier::JourneySegmentTriggerNode::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+      # group, or an AND/OR nested group. Omit the `conditions` property entirely to
+      # express "no conditions".
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup,
+              Courier::JourneyConditionNestedGroup
+            )
+          )
+        )
+      end
+      attr_reader :conditions
+
+      sig do
+        params(
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            )
+        ).void
+      end
+      attr_writer :conditions
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :event_id
+
+      sig { params(event_id: String).void }
+      attr_writer :event_id
+
+      # Trigger fired by a segment event (`identify`, `group`, or `track`).
+      sig do
+        params(
+          request_type:
+            Courier::JourneySegmentTriggerNode::RequestType::OrSymbol,
+          trigger_type:
+            Courier::JourneySegmentTriggerNode::TriggerType::OrSymbol,
+          type: Courier::JourneySegmentTriggerNode::Type::OrSymbol,
+          id: String,
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            ),
+          event_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        request_type:,
+        trigger_type:,
+        type:,
+        id: nil,
+        # Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+        # group, or an AND/OR nested group. Omit the `conditions` property entirely to
+        # express "no conditions".
+        conditions: nil,
+        event_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            request_type:
+              Courier::JourneySegmentTriggerNode::RequestType::OrSymbol,
+            trigger_type:
+              Courier::JourneySegmentTriggerNode::TriggerType::OrSymbol,
+            type: Courier::JourneySegmentTriggerNode::Type::OrSymbol,
+            id: String,
+            conditions:
+              T.any(
+                T::Array[String],
+                Courier::JourneyConditionGroup,
+                Courier::JourneyConditionNestedGroup
+              ),
+            event_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module RequestType
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneySegmentTriggerNode::RequestType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        IDENTIFY =
+          T.let(
+            :identify,
+            Courier::JourneySegmentTriggerNode::RequestType::TaggedSymbol
+          )
+        GROUP =
+          T.let(
+            :group,
+            Courier::JourneySegmentTriggerNode::RequestType::TaggedSymbol
+          )
+        TRACK =
+          T.let(
+            :track,
+            Courier::JourneySegmentTriggerNode::RequestType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Courier::JourneySegmentTriggerNode::RequestType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module TriggerType
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneySegmentTriggerNode::TriggerType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SEGMENT =
+          T.let(
+            :segment,
+            Courier::JourneySegmentTriggerNode::TriggerType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Courier::JourneySegmentTriggerNode::TriggerType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneySegmentTriggerNode::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRIGGER =
+          T.let(
+            :trigger,
+            Courier::JourneySegmentTriggerNode::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneySegmentTriggerNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_send_node.rbi

@@ -0,0 +1,254 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneySendNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneySendNode, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(Courier::JourneySendNode::Message) }
+      attr_reader :message
+
+      sig { params(message: Courier::JourneySendNode::Message::OrHash).void }
+      attr_writer :message
+
+      sig { returns(Courier::JourneySendNode::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+      # group, or an AND/OR nested group. Omit the `conditions` property entirely to
+      # express "no conditions".
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup,
+              Courier::JourneyConditionNestedGroup
+            )
+          )
+        )
+      end
+      attr_reader :conditions
+
+      sig do
+        params(
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            )
+        ).void
+      end
+      attr_writer :conditions
+
+      # Send a notification template to the recipient. Optionally override the recipient
+      # address, delay the send, or attach `data`.
+      sig do
+        params(
+          message: Courier::JourneySendNode::Message::OrHash,
+          type: Courier::JourneySendNode::Type::OrSymbol,
+          id: String,
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            )
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        message:,
+        type:,
+        id: nil,
+        # Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+        # group, or an AND/OR nested group. Omit the `conditions` property entirely to
+        # express "no conditions".
+        conditions: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            message: Courier::JourneySendNode::Message,
+            type: Courier::JourneySendNode::Type::OrSymbol,
+            id: String,
+            conditions:
+              T.any(
+                T::Array[String],
+                Courier::JourneyConditionGroup,
+                Courier::JourneyConditionNestedGroup
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Message < Courier::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Courier::JourneySendNode::Message, Courier::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :template
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :data
+
+        sig { params(data: T::Hash[Symbol, T.anything]).void }
+        attr_writer :data
+
+        sig { returns(T.nilable(Courier::JourneySendNode::Message::Delay)) }
+        attr_reader :delay
+
+        sig do
+          params(delay: Courier::JourneySendNode::Message::Delay::OrHash).void
+        end
+        attr_writer :delay
+
+        sig { returns(T.nilable(Courier::JourneySendNode::Message::To)) }
+        attr_reader :to
+
+        sig { params(to: Courier::JourneySendNode::Message::To::OrHash).void }
+        attr_writer :to
+
+        sig do
+          params(
+            template: String,
+            data: T::Hash[Symbol, T.anything],
+            delay: Courier::JourneySendNode::Message::Delay::OrHash,
+            to: Courier::JourneySendNode::Message::To::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(template:, data: nil, delay: nil, to: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              template: String,
+              data: T::Hash[Symbol, T.anything],
+              delay: Courier::JourneySendNode::Message::Delay,
+              to: Courier::JourneySendNode::Message::To
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Delay < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::JourneySendNode::Message::Delay,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :until_
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :timezone
+
+          sig { params(timezone: String).void }
+          attr_writer :timezone
+
+          sig do
+            params(until_: String, timezone: String).returns(T.attached_class)
+          end
+          def self.new(until_:, timezone: nil)
+          end
+
+          sig { override.returns({ until_: String, timezone: String }) }
+          def to_hash
+          end
+        end
+
+        class To < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::JourneySendNode::Message::To,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :email_override
+
+          sig { params(email_override: String).void }
+          attr_writer :email_override
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :phone_number_override
+
+          sig { params(phone_number_override: String).void }
+          attr_writer :phone_number_override
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :user_id_override
+
+          sig { params(user_id_override: String).void }
+          attr_writer :user_id_override
+
+          sig do
+            params(
+              email_override: String,
+              phone_number_override: String,
+              user_id_override: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            email_override: nil,
+            phone_number_override: nil,
+            user_id_override: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                email_override: String,
+                phone_number_override: String,
+                user_id_override: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Courier::JourneySendNode::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SEND = T.let(:send, Courier::JourneySendNode::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneySendNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_state.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Courier
+  module Models
+    # Lifecycle state of a journey.
+    module JourneyState
+      extend Courier::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Courier::JourneyState) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      DRAFT = T.let(:DRAFT, Courier::JourneyState::TaggedSymbol)
+      PUBLISHED = T.let(:PUBLISHED, Courier::JourneyState::TaggedSymbol)
+
+      sig { override.returns(T::Array[Courier::JourneyState::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end