trycourier 4.8.0 → 4.10.0

data/rbi/courier/models/notification_content_put_request.rbi

@@ -0,0 +1,145 @@
+# typed: strong
+
+module Courier
+  module Models
+    class NotificationContentPutRequest < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::NotificationContentPutRequest,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      # Elemental content payload. The server defaults `version` when omitted.
+      sig { returns(Courier::NotificationContentPutRequest::Content) }
+      attr_reader :content
+
+      sig do
+        params(
+          content: Courier::NotificationContentPutRequest::Content::OrHash
+        ).void
+      end
+      attr_writer :content
+
+      # Template state. Defaults to `DRAFT`.
+      sig { returns(T.nilable(Courier::NotificationTemplateState::OrSymbol)) }
+      attr_reader :state
+
+      sig { params(state: Courier::NotificationTemplateState::OrSymbol).void }
+      attr_writer :state
+
+      # Request body for replacing the elemental content of a notification template.
+      sig do
+        params(
+          content: Courier::NotificationContentPutRequest::Content::OrHash,
+          state: Courier::NotificationTemplateState::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Elemental content payload. The server defaults `version` when omitted.
+        content:,
+        # Template state. Defaults to `DRAFT`.
+        state: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            content: Courier::NotificationContentPutRequest::Content,
+            state: Courier::NotificationTemplateState::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Content < Courier::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Courier::NotificationContentPutRequest::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
+
+        # Content version identifier (e.g., `2022-01-01`). Optional; server defaults when
+        # omitted.
+        sig { returns(T.nilable(String)) }
+        attr_reader :version
+
+        sig { params(version: String).void }
+        attr_writer :version
+
+        # Elemental content payload. The server defaults `version` when omitted.
+        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: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          elements:,
+          # Content version identifier (e.g., `2022-01-01`). Optional; server defaults when
+          # omitted.
+          version: 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: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notification_create_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Courier
+  module Models
+    class NotificationCreateParams < Courier::Models::NotificationTemplateCreateRequest
+      extend Courier::Internal::Type::RequestParameters::Converter
+      include Courier::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Courier::NotificationCreateParams, Courier::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: Courier::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Courier::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/notification_element_put_request.rbi

@@ -0,0 +1,98 @@
+# typed: strong
+
+module Courier
+  module Models
+    class NotificationElementPutRequest < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::NotificationElementPutRequest,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      # Element type (text, meta, action, image, etc.).
+      sig { returns(String) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :channels
+
+      sig { params(channels: T::Array[String]).void }
+      attr_writer :channels
+
+      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(String)) }
+      attr_reader :if_
+
+      sig { params(if_: String).void }
+      attr_writer :if_
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :loop_
+
+      sig { params(loop_: String).void }
+      attr_writer :loop_
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :ref
+
+      sig { params(ref: String).void }
+      attr_writer :ref
+
+      # Template state. Defaults to `DRAFT`.
+      sig { returns(T.nilable(Courier::NotificationTemplateState::OrSymbol)) }
+      attr_reader :state
+
+      sig { params(state: Courier::NotificationTemplateState::OrSymbol).void }
+      attr_writer :state
+
+      # Request body for updating a single element. Additional type-specific fields are
+      # allowed.
+      sig do
+        params(
+          type: String,
+          channels: T::Array[String],
+          data: T::Hash[Symbol, T.anything],
+          if_: String,
+          loop_: String,
+          ref: String,
+          state: Courier::NotificationTemplateState::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Element type (text, meta, action, image, etc.).
+        type:,
+        channels: nil,
+        data: nil,
+        if_: nil,
+        loop_: nil,
+        ref: nil,
+        # Template state. Defaults to `DRAFT`.
+        state: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            type: String,
+            channels: T::Array[String],
+            data: T::Hash[Symbol, T.anything],
+            if_: String,
+            loop_: String,
+            ref: String,
+            state: Courier::NotificationTemplateState::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/notification_list_params.rbi

@@ -11,23 +11,35 @@ module Courier
           T.any(Courier::NotificationListParams, Courier::Internal::AnyHash)
         end
 
+      # Opaque pagination cursor from a previous response. Omit for the first page.
       sig { returns(T.nilable(String)) }
       attr_accessor :cursor
 
-      # Retrieve the notes from the Notification template settings.
+      # Filter to templates linked to this event map ID.
+      sig { returns(T.nilable(String)) }
+      attr_reader :event_id
+
+      sig { params(event_id: String).void }
+      attr_writer :event_id
+
+      # Include template notes in the response. Only applies to legacy templates.
       sig { returns(T.nilable(T::Boolean)) }
       attr_accessor :notes
 
       sig do
         params(
           cursor: T.nilable(String),
+          event_id: String,
           notes: T.nilable(T::Boolean),
           request_options: Courier::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
+        # Opaque pagination cursor from a previous response. Omit for the first page.
         cursor: nil,
-        # Retrieve the notes from the Notification template settings.
+        # Filter to templates linked to this event map ID.
+        event_id: nil,
+        # Include template notes in the response. Only applies to legacy templates.
         notes: nil,
         request_options: {}
       )
@@ -37,6 +49,7 @@ module Courier
         override.returns(
           {
             cursor: T.nilable(String),
+            event_id: String,
             notes: T.nilable(T::Boolean),
             request_options: Courier::RequestOptions
           }

data/rbi/courier/models/notification_list_response.rbi

@@ -17,8 +17,11 @@ module Courier
       sig { params(paging: Courier::Paging::OrHash).void }
       attr_writer :paging
 
+      # Notification templates in this workspace.
       sig do
-        returns(T::Array[Courier::Models::NotificationListResponse::Result])
+        returns(
+          T::Array[Courier::Models::NotificationListResponse::Result::Variants]
+        )
       end
       attr_accessor :results
 
@@ -26,194 +29,231 @@ module Courier
         params(
           paging: Courier::Paging::OrHash,
           results:
-            T::Array[Courier::Models::NotificationListResponse::Result::OrHash]
+            T::Array[
+              T.any(
+                Courier::Models::NotificationListResponse::Result::Notification::OrHash,
+                Courier::NotificationTemplateSummary::OrHash
+              )
+            ]
         ).returns(T.attached_class)
       end
-      def self.new(paging:, results:)
+      def self.new(
+        paging:,
+        # Notification templates in this workspace.
+        results:
+      )
       end
 
       sig do
         override.returns(
           {
             paging: Courier::Paging,
-            results: T::Array[Courier::Models::NotificationListResponse::Result]
+            results:
+              T::Array[
+                Courier::Models::NotificationListResponse::Result::Variants
+              ]
           }
         )
       end
       def to_hash
       end
 
-      class Result < Courier::Internal::Type::BaseModel
-        OrHash =
+      # V2 (CDS) template summary returned in list responses.
+      module Result
+        extend Courier::Internal::Type::Union
+
+        Variants =
           T.type_alias do
             T.any(
-              Courier::Models::NotificationListResponse::Result,
-              Courier::Internal::AnyHash
+              Courier::Models::NotificationListResponse::Result::Notification,
+              Courier::NotificationTemplateSummary
             )
           end
 
-        sig { returns(String) }
-        attr_accessor :id
+        class Notification < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::Models::NotificationListResponse::Result::Notification,
+                Courier::Internal::AnyHash
+              )
+            end
 
-        sig { returns(Integer) }
-        attr_accessor :created_at
+          sig { returns(String) }
+          attr_accessor :id
 
-        # Array of event IDs associated with this notification
-        sig { returns(T::Array[String]) }
-        attr_accessor :event_ids
+          sig { returns(Integer) }
+          attr_accessor :created_at
 
-        sig { returns(String) }
-        attr_accessor :note
+          # Array of event IDs associated with this notification
+          sig { returns(T::Array[String]) }
+          attr_accessor :event_ids
 
-        sig { returns(Courier::MessageRouting) }
-        attr_reader :routing
+          sig { returns(String) }
+          attr_accessor :note
 
-        sig { params(routing: Courier::MessageRouting::OrHash).void }
-        attr_writer :routing
+          sig { returns(Courier::MessageRouting) }
+          attr_reader :routing
 
-        sig { returns(String) }
-        attr_accessor :topic_id
+          sig { params(routing: Courier::MessageRouting::OrHash).void }
+          attr_writer :routing
 
-        sig { returns(Integer) }
-        attr_accessor :updated_at
+          sig { returns(String) }
+          attr_accessor :topic_id
 
-        sig do
-          returns(
-            T.nilable(Courier::Models::NotificationListResponse::Result::Tags)
-          )
-        end
-        attr_reader :tags
+          sig { returns(Integer) }
+          attr_accessor :updated_at
 
-        sig do
-          params(
-            tags:
+          sig do
+            returns(
               T.nilable(
-                Courier::Models::NotificationListResponse::Result::Tags::OrHash
+                Courier::Models::NotificationListResponse::Result::Notification::Tags
               )
-          ).void
-        end
-        attr_writer :tags
+            )
+          end
+          attr_reader :tags
 
-        sig { returns(T.nilable(String)) }
-        attr_accessor :title
+          sig do
+            params(
+              tags:
+                T.nilable(
+                  Courier::Models::NotificationListResponse::Result::Notification::Tags::OrHash
+                )
+            ).void
+          end
+          attr_writer :tags
 
-        sig do
-          params(
-            id: String,
-            created_at: Integer,
-            event_ids: T::Array[String],
-            note: String,
-            routing: Courier::MessageRouting::OrHash,
-            topic_id: String,
-            updated_at: Integer,
-            tags:
-              T.nilable(
-                Courier::Models::NotificationListResponse::Result::Tags::OrHash
-              ),
-            title: T.nilable(String)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          id:,
-          created_at:,
-          # Array of event IDs associated with this notification
-          event_ids:,
-          note:,
-          routing:,
-          topic_id:,
-          updated_at:,
-          tags: nil,
-          title: nil
-        )
-        end
+          sig { returns(T.nilable(String)) }
+          attr_accessor :title
 
-        sig do
-          override.returns(
-            {
+          sig do
+            params(
               id: String,
               created_at: Integer,
               event_ids: T::Array[String],
               note: String,
-              routing: Courier::MessageRouting,
+              routing: Courier::MessageRouting::OrHash,
               topic_id: String,
               updated_at: Integer,
               tags:
                 T.nilable(
-                  Courier::Models::NotificationListResponse::Result::Tags
+                  Courier::Models::NotificationListResponse::Result::Notification::Tags::OrHash
                 ),
               title: T.nilable(String)
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Tags < Courier::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Courier::Models::NotificationListResponse::Result::Tags,
-                Courier::Internal::AnyHash
-              )
-            end
-
-          sig do
-            returns(
-              T::Array[
-                Courier::Models::NotificationListResponse::Result::Tags::Data
-              ]
-            )
-          end
-          attr_accessor :data
-
-          sig do
-            params(
-              data:
-                T::Array[
-                  Courier::Models::NotificationListResponse::Result::Tags::Data::OrHash
-                ]
             ).returns(T.attached_class)
           end
-          def self.new(data:)
+          def self.new(
+            id:,
+            created_at:,
+            # Array of event IDs associated with this notification
+            event_ids:,
+            note:,
+            routing:,
+            topic_id:,
+            updated_at:,
+            tags: nil,
+            title: nil
+          )
           end
 
           sig do
             override.returns(
               {
-                data:
-                  T::Array[
-                    Courier::Models::NotificationListResponse::Result::Tags::Data
-                  ]
+                id: String,
+                created_at: Integer,
+                event_ids: T::Array[String],
+                note: String,
+                routing: Courier::MessageRouting,
+                topic_id: String,
+                updated_at: Integer,
+                tags:
+                  T.nilable(
+                    Courier::Models::NotificationListResponse::Result::Notification::Tags
+                  ),
+                title: T.nilable(String)
               }
             )
           end
           def to_hash
           end
 
-          class Data < Courier::Internal::Type::BaseModel
+          class Tags < Courier::Internal::Type::BaseModel
             OrHash =
               T.type_alias do
                 T.any(
-                  Courier::Models::NotificationListResponse::Result::Tags::Data,
+                  Courier::Models::NotificationListResponse::Result::Notification::Tags,
                   Courier::Internal::AnyHash
                 )
               end
 
-            sig { returns(String) }
-            attr_accessor :id
-
-            sig { returns(String) }
-            attr_accessor :name
+            sig do
+              returns(
+                T::Array[
+                  Courier::Models::NotificationListResponse::Result::Notification::Tags::Data
+                ]
+              )
+            end
+            attr_accessor :data
 
-            sig { params(id: String, name: String).returns(T.attached_class) }
-            def self.new(id:, name:)
+            sig do
+              params(
+                data:
+                  T::Array[
+                    Courier::Models::NotificationListResponse::Result::Notification::Tags::Data::OrHash
+                  ]
+              ).returns(T.attached_class)
+            end
+            def self.new(data:)
             end
 
-            sig { override.returns({ id: String, name: String }) }
+            sig do
+              override.returns(
+                {
+                  data:
+                    T::Array[
+                      Courier::Models::NotificationListResponse::Result::Notification::Tags::Data
+                    ]
+                }
+              )
+            end
             def to_hash
             end
+
+            class Data < Courier::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Courier::Models::NotificationListResponse::Result::Notification::Tags::Data,
+                    Courier::Internal::AnyHash
+                  )
+                end
+
+              sig { returns(String) }
+              attr_accessor :id
+
+              sig { returns(String) }
+              attr_accessor :name
+
+              sig { params(id: String, name: String).returns(T.attached_class) }
+              def self.new(id:, name:)
+              end
+
+              sig { override.returns({ id: String, name: String }) }
+              def to_hash
+              end
+            end
           end
         end
+
+        sig do
+          override.returns(
+            T::Array[
+              Courier::Models::NotificationListResponse::Result::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
       end
     end
   end