trycourier 4.6.3 → 4.7.0

data/rbi/courier/models/tenant_template_input.rbi

@@ -0,0 +1,408 @@
+# typed: strong
+
+module Courier
+  module Models
+    class TenantTemplateInput < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::TenantTemplateInput, Courier::Internal::AnyHash)
+        end
+
+      # Template content configuration including blocks, elements, and message structure
+      sig { returns(Courier::ElementalContent) }
+      attr_reader :content
+
+      sig { params(content: Courier::ElementalContent::OrHash).void }
+      attr_writer :content
+
+      # Channel-specific delivery configuration (email, SMS, push, etc.)
+      sig do
+        returns(
+          T.nilable(T::Hash[Symbol, Courier::TenantTemplateInput::Channel])
+        )
+      end
+      attr_reader :channels
+
+      sig do
+        params(
+          channels:
+            T::Hash[Symbol, Courier::TenantTemplateInput::Channel::OrHash]
+        ).void
+      end
+      attr_writer :channels
+
+      # Provider-specific delivery configuration for routing to specific email/SMS
+      # providers
+      sig do
+        returns(
+          T.nilable(T::Hash[Symbol, Courier::TenantTemplateInput::Provider])
+        )
+      end
+      attr_reader :providers
+
+      sig do
+        params(
+          providers:
+            T::Hash[Symbol, Courier::TenantTemplateInput::Provider::OrHash]
+        ).void
+      end
+      attr_writer :providers
+
+      # Message routing configuration for multi-channel delivery strategies
+      sig { returns(T.nilable(Courier::MessageRouting)) }
+      attr_reader :routing
+
+      sig { params(routing: Courier::MessageRouting::OrHash).void }
+      attr_writer :routing
+
+      # Template configuration for creating or updating a tenant notification template
+      sig do
+        params(
+          content: Courier::ElementalContent::OrHash,
+          channels:
+            T::Hash[Symbol, Courier::TenantTemplateInput::Channel::OrHash],
+          providers:
+            T::Hash[Symbol, Courier::TenantTemplateInput::Provider::OrHash],
+          routing: Courier::MessageRouting::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Template content configuration including blocks, elements, and message structure
+        content:,
+        # Channel-specific delivery configuration (email, SMS, push, etc.)
+        channels: nil,
+        # Provider-specific delivery configuration for routing to specific email/SMS
+        # providers
+        providers: nil,
+        # Message routing configuration for multi-channel delivery strategies
+        routing: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            content: Courier::ElementalContent,
+            channels: T::Hash[Symbol, Courier::TenantTemplateInput::Channel],
+            providers: T::Hash[Symbol, Courier::TenantTemplateInput::Provider],
+            routing: Courier::MessageRouting
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Channel < Courier::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Courier::TenantTemplateInput::Channel,
+              Courier::Internal::AnyHash
+            )
+          end
+
+        # Brand id used for rendering.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :brand_id
+
+        # JS conditional with access to data/profile.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :if_
+
+        sig do
+          returns(T.nilable(Courier::TenantTemplateInput::Channel::Metadata))
+        end
+        attr_reader :metadata
+
+        sig do
+          params(
+            metadata:
+              T.nilable(Courier::TenantTemplateInput::Channel::Metadata::OrHash)
+          ).void
+        end
+        attr_writer :metadata
+
+        # Channel specific overrides.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :override
+
+        # Providers enabled for this channel.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :providers
+
+        # Defaults to `single`.
+        sig do
+          returns(
+            T.nilable(
+              Courier::TenantTemplateInput::Channel::RoutingMethod::OrSymbol
+            )
+          )
+        end
+        attr_accessor :routing_method
+
+        sig do
+          returns(T.nilable(Courier::TenantTemplateInput::Channel::Timeouts))
+        end
+        attr_reader :timeouts
+
+        sig do
+          params(
+            timeouts:
+              T.nilable(Courier::TenantTemplateInput::Channel::Timeouts::OrHash)
+          ).void
+        end
+        attr_writer :timeouts
+
+        sig do
+          params(
+            brand_id: T.nilable(String),
+            if_: T.nilable(String),
+            metadata:
+              T.nilable(
+                Courier::TenantTemplateInput::Channel::Metadata::OrHash
+              ),
+            override: T.nilable(T::Hash[Symbol, T.anything]),
+            providers: T.nilable(T::Array[String]),
+            routing_method:
+              T.nilable(
+                Courier::TenantTemplateInput::Channel::RoutingMethod::OrSymbol
+              ),
+            timeouts:
+              T.nilable(Courier::TenantTemplateInput::Channel::Timeouts::OrHash)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Brand id used for rendering.
+          brand_id: nil,
+          # JS conditional with access to data/profile.
+          if_: nil,
+          metadata: nil,
+          # Channel specific overrides.
+          override: nil,
+          # Providers enabled for this channel.
+          providers: nil,
+          # Defaults to `single`.
+          routing_method: nil,
+          timeouts: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              brand_id: T.nilable(String),
+              if_: T.nilable(String),
+              metadata:
+                T.nilable(Courier::TenantTemplateInput::Channel::Metadata),
+              override: T.nilable(T::Hash[Symbol, T.anything]),
+              providers: T.nilable(T::Array[String]),
+              routing_method:
+                T.nilable(
+                  Courier::TenantTemplateInput::Channel::RoutingMethod::OrSymbol
+                ),
+              timeouts:
+                T.nilable(Courier::TenantTemplateInput::Channel::Timeouts)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Metadata < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::TenantTemplateInput::Channel::Metadata,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(Courier::Utm)) }
+          attr_reader :utm
+
+          sig { params(utm: T.nilable(Courier::Utm::OrHash)).void }
+          attr_writer :utm
+
+          sig do
+            params(utm: T.nilable(Courier::Utm::OrHash)).returns(
+              T.attached_class
+            )
+          end
+          def self.new(utm: nil)
+          end
+
+          sig { override.returns({ utm: T.nilable(Courier::Utm) }) }
+          def to_hash
+          end
+        end
+
+        # Defaults to `single`.
+        module RoutingMethod
+          extend Courier::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Courier::TenantTemplateInput::Channel::RoutingMethod
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ALL =
+            T.let(
+              :all,
+              Courier::TenantTemplateInput::Channel::RoutingMethod::TaggedSymbol
+            )
+          SINGLE =
+            T.let(
+              :single,
+              Courier::TenantTemplateInput::Channel::RoutingMethod::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Courier::TenantTemplateInput::Channel::RoutingMethod::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class Timeouts < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::TenantTemplateInput::Channel::Timeouts,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :channel
+
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :provider
+
+          sig do
+            params(
+              channel: T.nilable(Integer),
+              provider: T.nilable(Integer)
+            ).returns(T.attached_class)
+          end
+          def self.new(channel: nil, provider: nil)
+          end
+
+          sig do
+            override.returns(
+              { channel: T.nilable(Integer), provider: T.nilable(Integer) }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+
+      class Provider < Courier::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Courier::TenantTemplateInput::Provider,
+              Courier::Internal::AnyHash
+            )
+          end
+
+        # JS conditional with access to data/profile.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :if_
+
+        sig do
+          returns(T.nilable(Courier::TenantTemplateInput::Provider::Metadata))
+        end
+        attr_reader :metadata
+
+        sig do
+          params(
+            metadata:
+              T.nilable(
+                Courier::TenantTemplateInput::Provider::Metadata::OrHash
+              )
+          ).void
+        end
+        attr_writer :metadata
+
+        # Provider-specific overrides.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :override
+
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :timeouts
+
+        sig do
+          params(
+            if_: T.nilable(String),
+            metadata:
+              T.nilable(
+                Courier::TenantTemplateInput::Provider::Metadata::OrHash
+              ),
+            override: T.nilable(T::Hash[Symbol, T.anything]),
+            timeouts: T.nilable(Integer)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # JS conditional with access to data/profile.
+          if_: nil,
+          metadata: nil,
+          # Provider-specific overrides.
+          override: nil,
+          timeouts: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              if_: T.nilable(String),
+              metadata:
+                T.nilable(Courier::TenantTemplateInput::Provider::Metadata),
+              override: T.nilable(T::Hash[Symbol, T.anything]),
+              timeouts: T.nilable(Integer)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Metadata < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::TenantTemplateInput::Provider::Metadata,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(Courier::Utm)) }
+          attr_reader :utm
+
+          sig { params(utm: T.nilable(Courier::Utm::OrHash)).void }
+          attr_writer :utm
+
+          sig do
+            params(utm: T.nilable(Courier::Utm::OrHash)).returns(
+              T.attached_class
+            )
+          end
+          def self.new(utm: nil)
+          end
+
+          sig { override.returns({ utm: T.nilable(Courier::Utm) }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/tenants/template_publish_params.rbi

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

data/rbi/courier/models/tenants/template_replace_params.rbi

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

data/rbi/courier/models/tenants/templates/version_retrieve_params.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Tenants
+      module Templates
+        class VersionRetrieveParams < Courier::Internal::Type::BaseModel
+          extend Courier::Internal::Type::RequestParameters::Converter
+          include Courier::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::Tenants::Templates::VersionRetrieveParams,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :tenant_id
+
+          sig { returns(String) }
+          attr_accessor :template_id
+
+          sig do
+            params(
+              tenant_id: String,
+              template_id: String,
+              request_options: Courier::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(tenant_id:, template_id:, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              {
+                tenant_id: String,
+                template_id: String,
+                request_options: Courier::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models.rbi

@@ -205,6 +205,12 @@ module Courier
 
   Paging = Courier::Models::Paging
 
+  PostTenantTemplatePublishRequest =
+    Courier::Models::PostTenantTemplatePublishRequest
+
+  PostTenantTemplatePublishResponse =
+    Courier::Models::PostTenantTemplatePublishResponse
+
   Preference = Courier::Models::Preference
 
   PreferenceStatus = Courier::Models::PreferenceStatus
@@ -223,6 +229,10 @@ module Courier
 
   PutSubscriptionsRecipient = Courier::Models::PutSubscriptionsRecipient
 
+  PutTenantTemplateRequest = Courier::Models::PutTenantTemplateRequest
+
+  PutTenantTemplateResponse = Courier::Models::PutTenantTemplateResponse
+
   RecipientPreferences = Courier::Models::RecipientPreferences
 
   RequestArchiveParams = Courier::Models::RequestArchiveParams
@@ -277,6 +287,8 @@ module Courier
 
   Tenants = Courier::Models::Tenants
 
+  TenantTemplateInput = Courier::Models::TenantTemplateInput
+
   TenantUpdateParams = Courier::Models::TenantUpdateParams
 
   TextStyle = Courier::Models::TextStyle

data/rbi/courier/resources/tenants/templates/versions.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Courier
+  module Resources
+    class Tenants
+      class Templates
+        class Versions
+          # Fetches a specific version of a tenant template.
+          #
+          # Supports the following version formats:
+          #
+          # - `latest` - The most recent version of the template
+          # - `published` - The currently published version
+          # - `v{version}` - A specific version (e.g., "v1", "v2", "v1.0.0")
+          sig do
+            params(
+              version: String,
+              tenant_id: String,
+              template_id: String,
+              request_options: Courier::RequestOptions::OrHash
+            ).returns(Courier::BaseTemplateTenantAssociation)
+          end
+          def retrieve(
+            # Version of the template to retrieve. Accepts "latest", "published", or a
+            # specific version string (e.g., "v1", "v2").
+            version,
+            # Id of the tenant for which to retrieve the template.
+            tenant_id:,
+            # Id of the template to be retrieved.
+            template_id:,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Courier::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/resources/tenants/templates.rbi

@@ -4,6 +4,9 @@ module Courier
   module Resources
     class Tenants
       class Templates
+        sig { returns(Courier::Resources::Tenants::Templates::Versions) }
+        attr_reader :versions
+
         # Get a Template in Tenant
         sig do
           params(
@@ -41,6 +44,62 @@ module Courier
         )
         end
 
+        # Publishes a specific version of a notification template for a tenant.
+        #
+        # The template must already exist in the tenant's notification map. If no version
+        # is specified, defaults to publishing the "latest" version.
+        sig do
+          params(
+            template_id: String,
+            tenant_id: String,
+            version: String,
+            request_options: Courier::RequestOptions::OrHash
+          ).returns(Courier::PostTenantTemplatePublishResponse)
+        end
+        def publish(
+          # Path param: Id of the template to be published.
+          template_id,
+          # Path param: Id of the tenant that owns the template.
+          tenant_id:,
+          # Body param: The version of the template to publish (e.g., "v1", "v2", "latest").
+          # If not provided, defaults to "latest".
+          version: nil,
+          request_options: {}
+        )
+        end
+
+        # Creates or updates a notification template for a tenant.
+        #
+        # If the template already exists for the tenant, it will be updated (200).
+        # Otherwise, a new template is created (201).
+        #
+        # Optionally publishes the template immediately if the `published` flag is set to
+        # true.
+        sig do
+          params(
+            template_id: String,
+            tenant_id: String,
+            template: Courier::TenantTemplateInput::OrHash,
+            published: T::Boolean,
+            request_options: Courier::RequestOptions::OrHash
+          ).returns(Courier::PutTenantTemplateResponse)
+        end
+        def replace(
+          # Path param: Id of the template to be created or updated.
+          template_id,
+          # Path param: Id of the tenant for which to create or update the template.
+          tenant_id:,
+          # Body param: Template configuration for creating or updating a tenant
+          # notification template
+          template:,
+          # Body param: Whether to publish the template immediately after saving. When true,
+          # the template becomes the active/published version. When false (default), the
+          # template is saved as a draft.
+          published: nil,
+          request_options: {}
+        )
+        end
+
         # @api private
         sig { params(client: Courier::Client).returns(T.attached_class) }
         def self.new(client:)

data/sig/courier/models/post_tenant_template_publish_request.rbs

@@ -0,0 +1,15 @@
+module Courier
+  module Models
+    type post_tenant_template_publish_request = { version: String }
+
+    class PostTenantTemplatePublishRequest < Courier::Internal::Type::BaseModel
+      attr_reader version: String?
+
+      def version=: (String) -> String
+
+      def initialize: (?version: String) -> void
+
+      def to_hash: -> { version: String }
+    end
+  end
+end