trycourier 4.8.0 → 4.10.0

data/rbi/courier/resources/notifications.rbi

@@ -3,34 +3,250 @@
 module Courier
   module Resources
     class Notifications
-      sig { returns(Courier::Resources::Notifications::Draft) }
-      attr_reader :draft
-
       sig { returns(Courier::Resources::Notifications::Checks) }
       attr_reader :checks
 
+      # Create a notification template. Requires all fields in the notification object.
+      # Templates are created in draft state by default.
+      sig do
+        params(
+          notification: Courier::NotificationTemplatePayload::OrHash,
+          state: Courier::NotificationTemplateCreateRequest::State::OrSymbol,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::NotificationTemplateMutationResponse)
+      end
+      def create(
+        # Full document shape used in POST and PUT request bodies, and returned inside the
+        # GET response envelope.
+        notification:,
+        # Template state after creation. Case-insensitive input, normalized to uppercase
+        # in the response. Defaults to "DRAFT".
+        state: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a notification template by ID. Returns the published version by
+      # default. Pass version=draft to retrieve an unpublished template.
+      sig do
+        params(
+          id: String,
+          version: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::NotificationTemplateGetResponse)
+      end
+      def retrieve(
+        # Template ID (nt\_ prefix).
+        id,
+        # Version to retrieve. One of "draft", "published", or a version string like
+        # "v001". Defaults to "published".
+        version: nil,
+        request_options: {}
+      )
+      end
+
+      # List notification templates in your workspace.
       sig do
         params(
           cursor: T.nilable(String),
+          event_id: String,
           notes: T.nilable(T::Boolean),
           request_options: Courier::RequestOptions::OrHash
         ).returns(Courier::Models::NotificationListResponse)
       end
       def list(
+        # 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: {}
       )
       end
 
+      # Archive a notification template.
+      sig do
+        params(
+          id: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).void
+      end
+      def archive(
+        # Template ID (nt\_ prefix).
+        id,
+        request_options: {}
+      )
+      end
+
+      # List versions of a notification template.
+      sig do
+        params(
+          id: String,
+          cursor: String,
+          limit: Integer,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::NotificationTemplateVersionListResponse)
+      end
+      def list_versions(
+        # Template ID (nt\_ prefix).
+        id,
+        # Opaque pagination cursor from a previous response. Omit for the first page.
+        cursor: nil,
+        # Maximum number of versions to return per page. Default 10, max 10.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # Publish a notification template. Publishes the current draft by default. Pass a
+      # version in the request body to publish a specific historical version.
+      sig do
+        params(
+          id: String,
+          version: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).void
+      end
+      def publish(
+        # Template ID (nt\_ prefix).
+        id,
+        # Historical version to publish (e.g. "v001"). Omit to publish the current draft.
+        version: nil,
+        request_options: {}
+      )
+      end
+
+      # Replace the elemental content of a notification template. Overwrites all
+      # elements in the template with the provided content. Only supported for V2
+      # (elemental) templates.
+      sig do
+        params(
+          id: String,
+          content: Courier::NotificationContentPutRequest::Content::OrHash,
+          state: Courier::NotificationTemplateState::OrSymbol,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::NotificationContentMutationResponse)
+      end
+      def put_content(
+        # Notification template ID (`nt_` prefix).
+        id,
+        # Elemental content payload. The server defaults `version` when omitted.
+        content:,
+        # Template state. Defaults to `DRAFT`.
+        state: nil,
+        request_options: {}
+      )
+      end
+
+      # Update a single element within a notification template. Only supported for V2
+      # (elemental) templates.
+      sig do
+        params(
+          element_id: String,
+          id: String,
+          type: String,
+          channels: T::Array[String],
+          data: T::Hash[Symbol, T.anything],
+          if_: String,
+          loop_: String,
+          ref: String,
+          state: Courier::NotificationTemplateState::OrSymbol,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::NotificationContentMutationResponse)
+      end
+      def put_element(
+        # Path param: Element ID within the template.
+        element_id,
+        # Path param: Notification template ID (`nt_` prefix).
+        id:,
+        # Body param: Element type (text, meta, action, image, etc.).
+        type:,
+        # Body param
+        channels: nil,
+        # Body param
+        data: nil,
+        # Body param
+        if_: nil,
+        # Body param
+        loop_: nil,
+        # Body param
+        ref: nil,
+        # Body param: Template state. Defaults to `DRAFT`.
+        state: nil,
+        request_options: {}
+      )
+      end
+
+      # Set locale-specific content overrides for a notification template. Each element
+      # override must reference an existing element by ID. Only supported for V2
+      # (elemental) templates.
       sig do
         params(
+          locale_id: String,
           id: String,
+          elements:
+            T::Array[Courier::NotificationLocalePutRequest::Element::OrHash],
+          state: Courier::NotificationTemplateState::OrSymbol,
           request_options: Courier::RequestOptions::OrHash
-        ).returns(Courier::NotificationGetContent)
+        ).returns(Courier::NotificationContentMutationResponse)
+      end
+      def put_locale(
+        # Path param: Locale code (e.g., `es`, `fr`, `pt-BR`).
+        locale_id,
+        # Path param: Notification template ID (`nt_` prefix).
+        id:,
+        # Body param: Elements with locale-specific content overrides.
+        elements:,
+        # Body param: Template state. Defaults to `DRAFT`.
+        state: nil,
+        request_options: {}
+      )
       end
-      def retrieve_content(id, request_options: {})
+
+      # Replace a notification template. All fields are required.
+      sig do
+        params(
+          id: String,
+          notification: Courier::NotificationTemplatePayload::OrHash,
+          state: Courier::NotificationTemplateUpdateRequest::State::OrSymbol,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::NotificationTemplateMutationResponse)
+      end
+      def replace(
+        # Template ID (nt\_ prefix).
+        id,
+        # Full document shape used in POST and PUT request bodies, and returned inside the
+        # GET response envelope.
+        notification:,
+        # Template state after update. Case-insensitive input, normalized to uppercase in
+        # the response. Defaults to "DRAFT".
+        state: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve the content of a notification template. The response shape depends on
+      # whether the template uses V1 (blocks/channels) or V2 (elemental) content. Use
+      # the `version` query parameter to select draft, published, or a specific
+      # historical version.
+      sig do
+        params(
+          id: String,
+          version: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(
+          Courier::Models::NotificationRetrieveContentResponse::Variants
+        )
+      end
+      def retrieve_content(
+        # Notification template ID (`nt_` prefix).
+        id,
+        # Accepts `draft`, `published`, or a version string (e.g., `v001`). Defaults to
+        # `published`.
+        version: nil,
+        request_options: {}
+      )
       end
 
       # @api private

data/rbi/courier/resources/providers/catalog.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Courier
+  module Resources
+    class Providers
+      class Catalog
+        # Returns the catalog of available provider types with their display names,
+        # descriptions, and configuration schema fields (snake_case, with `type` and
+        # `required`). Providers with no configurable schema return only `provider`,
+        # `name`, and `description`.
+        sig do
+          params(
+            channel: String,
+            keys: String,
+            name: String,
+            request_options: Courier::RequestOptions::OrHash
+          ).returns(Courier::Models::Providers::CatalogListResponse)
+        end
+        def list(
+          # Exact match (case-insensitive) against the provider channel taxonomy (e.g.
+          # `email`, `sms`, `push`).
+          channel: nil,
+          # Comma-separated provider keys to filter by (e.g. `sendgrid,twilio`).
+          keys: nil,
+          # Case-insensitive substring match against the provider display name.
+          name: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Courier::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/courier/resources/providers.rbi

@@ -0,0 +1,116 @@
+# typed: strong
+
+module Courier
+  module Resources
+    class Providers
+      sig { returns(Courier::Resources::Providers::Catalog) }
+      attr_reader :catalog
+
+      # Create a new provider configuration. The `provider` field must be a known
+      # Courier provider key (see catalog).
+      sig do
+        params(
+          provider: String,
+          alias_: String,
+          settings: T::Hash[Symbol, T.anything],
+          title: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::Provider)
+      end
+      def create(
+        # The provider key identifying the type (e.g. "sendgrid", "twilio"). Must be a
+        # known Courier provider — see the catalog endpoint for valid keys.
+        provider:,
+        # Optional alias for this configuration.
+        alias_: nil,
+        # Provider-specific settings (snake_case keys). Defaults to an empty object when
+        # omitted. Use the catalog endpoint to discover required fields for a given
+        # provider — omitting a required field returns a 400 validation error.
+        settings: nil,
+        # Optional display title. Omit to use "Default Configuration".
+        title: nil,
+        request_options: {}
+      )
+      end
+
+      # Fetch a single provider configuration by ID.
+      sig do
+        params(
+          id: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::Provider)
+      end
+      def retrieve(
+        # A unique identifier of the provider configuration.
+        id,
+        request_options: {}
+      )
+      end
+
+      # Update an existing provider configuration. The `provider` key is required. All
+      # other fields are optional — omitted fields are cleared from the stored
+      # configuration (this is a full replacement, not a partial merge).
+      sig do
+        params(
+          id: String,
+          provider: String,
+          alias_: String,
+          settings: T::Hash[Symbol, T.anything],
+          title: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::Provider)
+      end
+      def update(
+        # A unique identifier of the provider configuration to update.
+        id,
+        # The provider key identifying the type.
+        provider:,
+        # Updated alias. Omit to clear.
+        alias_: nil,
+        # Provider-specific settings (snake_case keys). Replaces the full settings object
+        # — omitted settings fields are removed. Use the catalog endpoint to check
+        # required fields.
+        settings: nil,
+        # Updated display title.
+        title: nil,
+        request_options: {}
+      )
+      end
+
+      # List configured provider integrations for the current workspace. Supports
+      # cursor-based pagination.
+      sig do
+        params(
+          cursor: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::Models::ProviderListResponse)
+      end
+      def list(
+        # Opaque cursor for fetching the next page.
+        cursor: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete a provider configuration. Returns 409 if the provider is still referenced
+      # by routing or notifications.
+      sig do
+        params(
+          id: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).void
+      end
+      def delete(
+        # A unique identifier of the provider configuration to delete.
+        id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Courier::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/courier/resources/routing_strategies.rbi

@@ -0,0 +1,147 @@
+# typed: strong
+
+module Courier
+  module Resources
+    class RoutingStrategies
+      # Create a routing strategy. Requires a name and routing configuration at minimum.
+      # Channels and providers default to empty if omitted.
+      sig do
+        params(
+          name: String,
+          routing: Courier::MessageRouting::OrHash,
+          channels: T.nilable(T::Hash[Symbol, Courier::Channel::OrHash]),
+          description: T.nilable(String),
+          providers:
+            T.nilable(T::Hash[Symbol, Courier::MessageProvidersType::OrHash]),
+          tags: T.nilable(T::Array[String]),
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::RoutingStrategyMutationResponse)
+      end
+      def create(
+        # Human-readable name for the routing strategy.
+        name:,
+        # Routing tree defining channel selection method and order.
+        routing:,
+        # Per-channel delivery configuration. Defaults to empty if omitted.
+        channels: nil,
+        # Optional description of the routing strategy.
+        description: nil,
+        # Per-provider delivery configuration. Defaults to empty if omitted.
+        providers: nil,
+        # Optional tags for categorization.
+        tags: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a routing strategy by ID. Returns the full entity including routing
+      # content and metadata.
+      sig do
+        params(
+          id: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::RoutingStrategyGetResponse)
+      end
+      def retrieve(
+        # Routing strategy ID (rs\_ prefix).
+        id,
+        request_options: {}
+      )
+      end
+
+      # List routing strategies in your workspace. Returns metadata only (no
+      # routing/channels/providers content). Use GET /routing-strategies/{id} for full
+      # details.
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::RoutingStrategyListResponse)
+      end
+      def list(
+        # Opaque pagination cursor from a previous response. Omit for the first page.
+        cursor: nil,
+        # Maximum number of results per page. Default 20, max 100.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # Archive a routing strategy. The strategy must not have associated notification
+      # templates. Unlink all templates before archiving.
+      sig do
+        params(
+          id: String,
+          request_options: Courier::RequestOptions::OrHash
+        ).void
+      end
+      def archive(
+        # Routing strategy ID (rs\_ prefix).
+        id,
+        request_options: {}
+      )
+      end
+
+      # List notification templates associated with a routing strategy. Includes
+      # template metadata only, not full content.
+      sig do
+        params(
+          id: String,
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::AssociatedNotificationListResponse)
+      end
+      def list_notifications(
+        # Routing strategy ID (`rs_` prefix).
+        id,
+        # Opaque pagination cursor from a previous response. Omit for the first page.
+        cursor: nil,
+        # Maximum number of results per page. Default 20, max 100.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # Replace a routing strategy. Full document replacement; the caller must send the
+      # complete desired state. Missing optional fields are cleared.
+      sig do
+        params(
+          id: String,
+          name: String,
+          routing: Courier::MessageRouting::OrHash,
+          channels: T.nilable(T::Hash[Symbol, Courier::Channel::OrHash]),
+          description: T.nilable(String),
+          providers:
+            T.nilable(T::Hash[Symbol, Courier::MessageProvidersType::OrHash]),
+          tags: T.nilable(T::Array[String]),
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(Courier::RoutingStrategyMutationResponse)
+      end
+      def replace(
+        # Routing strategy ID (rs\_ prefix).
+        id,
+        # Human-readable name for the routing strategy.
+        name:,
+        # Routing tree defining channel selection method and order.
+        routing:,
+        # Per-channel delivery configuration. Omit to clear.
+        channels: nil,
+        # Optional description. Omit or null to clear.
+        description: nil,
+        # Per-provider delivery configuration. Omit to clear.
+        providers: nil,
+        # Optional tags. Omit or null to clear.
+        tags: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Courier::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/sig/courier/client.rbs

@@ -14,6 +14,8 @@ module Courier
 
     attr_reader audiences: Courier::Resources::Audiences
 
+    attr_reader providers: Courier::Resources::Providers
+
     attr_reader audit_events: Courier::Resources::AuditEvents
 
     attr_reader auth: Courier::Resources::Auth
@@ -36,6 +38,8 @@ module Courier
 
     attr_reader notifications: Courier::Resources::Notifications
 
+    attr_reader routing_strategies: Courier::Resources::RoutingStrategies
+
     attr_reader profiles: Courier::Resources::Profiles
 
     attr_reader tenants: Courier::Resources::Tenants

data/sig/courier/internal/util.rbs

@@ -45,8 +45,12 @@ module Courier
         -> top?
       } -> top?
 
+      RFC_3986_NOT_PCHARS: Regexp
+
       def self?.uri_origin: (URI::Generic uri) -> String
 
+      def self?.encode_path: (String | Integer path) -> String
+
       def self?.interpolate_path: (String | ::Array[String] path) -> String
 
       def self?.decode_query: (String? query) -> ::Hash[String, ::Array[String]]

data/sig/courier/models/associated_notification_list_response.rbs

@@ -0,0 +1,25 @@
+module Courier
+  module Models
+    type associated_notification_list_response =
+      {
+        paging: Courier::Paging,
+        results: ::Array[Courier::NotificationTemplateSummary]
+      }
+
+    class AssociatedNotificationListResponse < Courier::Internal::Type::BaseModel
+      attr_accessor paging: Courier::Paging
+
+      attr_accessor results: ::Array[Courier::NotificationTemplateSummary]
+
+      def initialize: (
+        paging: Courier::Paging,
+        results: ::Array[Courier::NotificationTemplateSummary]
+      ) -> void
+
+      def to_hash: -> {
+        paging: Courier::Paging,
+        results: ::Array[Courier::NotificationTemplateSummary]
+      }
+    end
+  end
+end

data/sig/courier/models/channel.rbs

@@ -0,0 +1,61 @@
+module Courier
+  module Models
+    type channel =
+      {
+        brand_id: String?,
+        if_: String?,
+        metadata: Courier::ChannelMetadata?,
+        override: ::Hash[Symbol, top]?,
+        providers: ::Array[String]?,
+        routing_method: Courier::Models::Channel::routing_method?,
+        timeouts: Courier::Timeouts?
+      }
+
+    class Channel < Courier::Internal::Type::BaseModel
+      attr_accessor brand_id: String?
+
+      attr_accessor if_: String?
+
+      attr_accessor metadata: Courier::ChannelMetadata?
+
+      attr_accessor override: ::Hash[Symbol, top]?
+
+      attr_accessor providers: ::Array[String]?
+
+      attr_accessor routing_method: Courier::Models::Channel::routing_method?
+
+      attr_accessor timeouts: Courier::Timeouts?
+
+      def initialize: (
+        ?brand_id: String?,
+        ?if_: String?,
+        ?metadata: Courier::ChannelMetadata?,
+        ?override: ::Hash[Symbol, top]?,
+        ?providers: ::Array[String]?,
+        ?routing_method: Courier::Models::Channel::routing_method?,
+        ?timeouts: Courier::Timeouts?
+      ) -> void
+
+      def to_hash: -> {
+        brand_id: String?,
+        if_: String?,
+        metadata: Courier::ChannelMetadata?,
+        override: ::Hash[Symbol, top]?,
+        providers: ::Array[String]?,
+        routing_method: Courier::Models::Channel::routing_method?,
+        timeouts: Courier::Timeouts?
+      }
+
+      type routing_method = :all | :single
+
+      module RoutingMethod
+        extend Courier::Internal::Type::Enum
+
+        ALL: :all
+        SINGLE: :single
+
+        def self?.values: -> ::Array[Courier::Models::Channel::routing_method]
+      end
+    end
+  end
+end

data/sig/courier/models/channel_metadata.rbs

@@ -0,0 +1,13 @@
+module Courier
+  module Models
+    type channel_metadata = { utm: Courier::Utm? }
+
+    class ChannelMetadata < Courier::Internal::Type::BaseModel
+      attr_accessor utm: Courier::Utm?
+
+      def initialize: (?utm: Courier::Utm?) -> void
+
+      def to_hash: -> { utm: Courier::Utm? }
+    end
+  end
+end