trycourier 4.10.2 → 4.11.0

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

data/rbi/courier/models/journey_template_create_request.rbi

@@ -0,0 +1,381 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyTemplateCreateRequest < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::JourneyTemplateCreateRequest,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :channel
+
+      sig { returns(Courier::JourneyTemplateCreateRequest::Notification) }
+      attr_reader :notification
+
+      sig do
+        params(
+          notification:
+            Courier::JourneyTemplateCreateRequest::Notification::OrHash
+        ).void
+      end
+      attr_writer :notification
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :provider_key
+
+      sig { params(provider_key: String).void }
+      attr_writer :provider_key
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :state
+
+      sig { params(state: String).void }
+      attr_writer :state
+
+      # Request body for creating a notification template scoped to a journey.
+      sig do
+        params(
+          channel: String,
+          notification:
+            Courier::JourneyTemplateCreateRequest::Notification::OrHash,
+          provider_key: String,
+          state: String
+        ).returns(T.attached_class)
+      end
+      def self.new(channel:, notification:, provider_key: nil, state: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: String,
+            notification: Courier::JourneyTemplateCreateRequest::Notification,
+            provider_key: String,
+            state: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Notification < Courier::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Courier::JourneyTemplateCreateRequest::Notification,
+              Courier::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(
+              Courier::JourneyTemplateCreateRequest::Notification::Brand
+            )
+          )
+        end
+        attr_reader :brand
+
+        sig do
+          params(
+            brand:
+              T.nilable(
+                Courier::JourneyTemplateCreateRequest::Notification::Brand::OrHash
+              )
+          ).void
+        end
+        attr_writer :brand
+
+        sig do
+          returns(Courier::JourneyTemplateCreateRequest::Notification::Content)
+        end
+        attr_reader :content
+
+        sig do
+          params(
+            content:
+              Courier::JourneyTemplateCreateRequest::Notification::Content::OrHash
+          ).void
+        end
+        attr_writer :content
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig do
+          returns(
+            T.nilable(
+              Courier::JourneyTemplateCreateRequest::Notification::Subscription
+            )
+          )
+        end
+        attr_reader :subscription
+
+        sig do
+          params(
+            subscription:
+              T.nilable(
+                Courier::JourneyTemplateCreateRequest::Notification::Subscription::OrHash
+              )
+          ).void
+        end
+        attr_writer :subscription
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :tags
+
+        sig do
+          params(
+            brand:
+              T.nilable(
+                Courier::JourneyTemplateCreateRequest::Notification::Brand::OrHash
+              ),
+            content:
+              Courier::JourneyTemplateCreateRequest::Notification::Content::OrHash,
+            name: String,
+            subscription:
+              T.nilable(
+                Courier::JourneyTemplateCreateRequest::Notification::Subscription::OrHash
+              ),
+            tags: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(brand:, content:, name:, subscription:, tags:)
+        end
+
+        sig do
+          override.returns(
+            {
+              brand:
+                T.nilable(
+                  Courier::JourneyTemplateCreateRequest::Notification::Brand
+                ),
+              content:
+                Courier::JourneyTemplateCreateRequest::Notification::Content,
+              name: String,
+              subscription:
+                T.nilable(
+                  Courier::JourneyTemplateCreateRequest::Notification::Subscription
+                ),
+              tags: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Brand < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::JourneyTemplateCreateRequest::Notification::Brand,
+                Courier::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
+
+        class Content < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::JourneyTemplateCreateRequest::Notification::Content,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T::Array[
+                T.any(
+                  Courier::ElementalTextNodeWithType,
+                  Courier::ElementalMetaNodeWithType,
+                  Courier::ElementalChannelNodeWithType,
+                  Courier::ElementalImageNodeWithType,
+                  Courier::ElementalActionNodeWithType,
+                  Courier::ElementalDividerNodeWithType,
+                  Courier::ElementalQuoteNodeWithType,
+                  Courier::ElementalHTMLNodeWithType
+                )
+              ]
+            )
+          end
+          attr_accessor :elements
+
+          sig do
+            returns(
+              Courier::JourneyTemplateCreateRequest::Notification::Content::Version::OrSymbol
+            )
+          end
+          attr_accessor :version
+
+          sig do
+            returns(
+              T.nilable(
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::OrSymbol
+              )
+            )
+          end
+          attr_reader :scope
+
+          sig do
+            params(
+              scope:
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::OrSymbol
+            ).void
+          end
+          attr_writer :scope
+
+          sig do
+            params(
+              elements:
+                T::Array[
+                  T.any(
+                    Courier::ElementalTextNodeWithType::OrHash,
+                    Courier::ElementalMetaNodeWithType::OrHash,
+                    Courier::ElementalChannelNodeWithType::OrHash,
+                    Courier::ElementalImageNodeWithType::OrHash,
+                    Courier::ElementalActionNodeWithType::OrHash,
+                    Courier::ElementalDividerNodeWithType::OrHash,
+                    Courier::ElementalQuoteNodeWithType::OrHash,
+                    Courier::ElementalHTMLNodeWithType::OrHash
+                  )
+                ],
+              version:
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Version::OrSymbol,
+              scope:
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(elements:, version:, scope: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                elements:
+                  T::Array[
+                    T.any(
+                      Courier::ElementalTextNodeWithType,
+                      Courier::ElementalMetaNodeWithType,
+                      Courier::ElementalChannelNodeWithType,
+                      Courier::ElementalImageNodeWithType,
+                      Courier::ElementalActionNodeWithType,
+                      Courier::ElementalDividerNodeWithType,
+                      Courier::ElementalQuoteNodeWithType,
+                      Courier::ElementalHTMLNodeWithType
+                    )
+                  ],
+                version:
+                  Courier::JourneyTemplateCreateRequest::Notification::Content::Version::OrSymbol,
+                scope:
+                  Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::OrSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Version
+            extend Courier::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Courier::JourneyTemplateCreateRequest::Notification::Content::Version
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            VERSION_2022_01_01 =
+              T.let(
+                :"2022-01-01",
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Version::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Courier::JourneyTemplateCreateRequest::Notification::Content::Version::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          module Scope
+            extend Courier::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Courier::JourneyTemplateCreateRequest::Notification::Content::Scope
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DEFAULT =
+              T.let(
+                :default,
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::TaggedSymbol
+              )
+            STRICT =
+              T.let(
+                :strict,
+                Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Courier::JourneyTemplateCreateRequest::Notification::Content::Scope::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class Subscription < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::JourneyTemplateCreateRequest::Notification::Subscription,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :topic_id
+
+          sig { params(topic_id: String).returns(T.attached_class) }
+          def self.new(topic_id:)
+          end
+
+          sig { override.returns({ topic_id: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end