trycourier 4.8.0 → 4.9.0

data/rbi/courier/models/providers_catalog_entry.rbi

@@ -0,0 +1,129 @@
+# typed: strong
+
+module Courier
+  module Models
+    class ProvidersCatalogEntry < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::ProvidersCatalogEntry, Courier::Internal::AnyHash)
+        end
+
+      # Courier taxonomy channel (e.g. email, push, sms, direct_message, inbox,
+      # webhook).
+      sig { returns(String) }
+      attr_accessor :channel
+
+      # Short description of the provider.
+      sig { returns(String) }
+      attr_accessor :description
+
+      # Human-readable display name.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # The provider key (e.g. "sendgrid", "twilio").
+      sig { returns(String) }
+      attr_accessor :provider
+
+      # Map of setting field names (snake_case) to their schema descriptors. Each
+      # descriptor has `type` and `required`. Empty when the provider has no
+      # configurable schema.
+      sig { returns(T::Hash[Symbol, Courier::ProvidersCatalogEntry::Setting]) }
+      attr_accessor :settings
+
+      # A provider type from the catalog. Contains the key, display name, description,
+      # and a `settings` object describing configuration schema fields.
+      sig do
+        params(
+          channel: String,
+          description: String,
+          name: String,
+          provider: String,
+          settings:
+            T::Hash[Symbol, Courier::ProvidersCatalogEntry::Setting::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Courier taxonomy channel (e.g. email, push, sms, direct_message, inbox,
+        # webhook).
+        channel:,
+        # Short description of the provider.
+        description:,
+        # Human-readable display name.
+        name:,
+        # The provider key (e.g. "sendgrid", "twilio").
+        provider:,
+        # Map of setting field names (snake_case) to their schema descriptors. Each
+        # descriptor has `type` and `required`. Empty when the provider has no
+        # configurable schema.
+        settings:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: String,
+            description: String,
+            name: String,
+            provider: String,
+            settings: T::Hash[Symbol, Courier::ProvidersCatalogEntry::Setting]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Setting < Courier::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Courier::ProvidersCatalogEntry::Setting,
+              Courier::Internal::AnyHash
+            )
+          end
+
+        # Whether this field is required when configuring the provider.
+        sig { returns(T::Boolean) }
+        attr_accessor :required
+
+        # The field's data type (e.g. "string", "boolean", "enum").
+        sig { returns(String) }
+        attr_accessor :type
+
+        # Allowed values when `type` is "enum".
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :values
+
+        sig { params(values: T::Array[String]).void }
+        attr_writer :values
+
+        # Describes a single configuration field in the provider catalog.
+        sig do
+          params(
+            required: T::Boolean,
+            type: String,
+            values: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Whether this field is required when configuring the provider.
+          required:,
+          # The field's data type (e.g. "string", "boolean", "enum").
+          type:,
+          # Allowed values when `type` is "enum".
+          values: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { required: T::Boolean, type: String, values: T::Array[String] }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_archive_params.rbi

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

data/rbi/courier/models/routing_strategy_create_params.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyCreateParams < Courier::Models::RoutingStrategyCreateRequest
+      extend Courier::Internal::Type::RequestParameters::Converter
+      include Courier::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::RoutingStrategyCreateParams,
+            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/routing_strategy_create_request.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyCreateRequest < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::RoutingStrategyCreateRequest,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      # Human-readable name for the routing strategy.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Routing tree defining channel selection method and order.
+      sig { returns(Courier::MessageRouting) }
+      attr_reader :routing
+
+      sig { params(routing: Courier::MessageRouting::OrHash).void }
+      attr_writer :routing
+
+      # Per-channel delivery configuration. Defaults to empty if omitted.
+      sig { returns(T.nilable(T::Hash[Symbol, Courier::Channel])) }
+      attr_accessor :channels
+
+      # Optional description of the routing strategy.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # Per-provider delivery configuration. Defaults to empty if omitted.
+      sig { returns(T.nilable(T::Hash[Symbol, Courier::MessageProvidersType])) }
+      attr_accessor :providers
+
+      # Optional tags for categorization.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :tags
+
+      # Request body for creating a routing strategy.
+      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])
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            routing: Courier::MessageRouting,
+            channels: T.nilable(T::Hash[Symbol, Courier::Channel]),
+            description: T.nilable(String),
+            providers:
+              T.nilable(T::Hash[Symbol, Courier::MessageProvidersType]),
+            tags: T.nilable(T::Array[String])
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_get_response.rbi

@@ -0,0 +1,121 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyGetResponse < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::RoutingStrategyGetResponse, Courier::Internal::AnyHash)
+        end
+
+      # The routing strategy ID (rs\_ prefix).
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Per-channel delivery configuration. May be empty.
+      sig { returns(T::Hash[Symbol, Courier::Channel]) }
+      attr_accessor :channels
+
+      # Epoch milliseconds when the strategy was created.
+      sig { returns(Integer) }
+      attr_accessor :created
+
+      # User ID of the creator.
+      sig { returns(String) }
+      attr_accessor :creator
+
+      # Human-readable name.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Per-provider delivery configuration. May be empty.
+      sig { returns(T::Hash[Symbol, Courier::MessageProvidersType]) }
+      attr_accessor :providers
+
+      # Routing tree defining channel selection method and order.
+      sig { returns(Courier::MessageRouting) }
+      attr_reader :routing
+
+      sig { params(routing: Courier::MessageRouting::OrHash).void }
+      attr_writer :routing
+
+      # Description of the routing strategy.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # Tags for categorization.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :tags
+
+      # Epoch milliseconds of last update.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :updated
+
+      # User ID of the last updater.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :updater
+
+      # Full routing strategy entity returned by GET.
+      sig do
+        params(
+          id: String,
+          channels: T::Hash[Symbol, Courier::Channel::OrHash],
+          created: Integer,
+          creator: String,
+          name: String,
+          providers: T::Hash[Symbol, Courier::MessageProvidersType::OrHash],
+          routing: Courier::MessageRouting::OrHash,
+          description: T.nilable(String),
+          tags: T.nilable(T::Array[String]),
+          updated: T.nilable(Integer),
+          updater: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The routing strategy ID (rs\_ prefix).
+        id:,
+        # Per-channel delivery configuration. May be empty.
+        channels:,
+        # Epoch milliseconds when the strategy was created.
+        created:,
+        # User ID of the creator.
+        creator:,
+        # Human-readable name.
+        name:,
+        # Per-provider delivery configuration. May be empty.
+        providers:,
+        # Routing tree defining channel selection method and order.
+        routing:,
+        # Description of the routing strategy.
+        description: nil,
+        # Tags for categorization.
+        tags: nil,
+        # Epoch milliseconds of last update.
+        updated: nil,
+        # User ID of the last updater.
+        updater: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            channels: T::Hash[Symbol, Courier::Channel],
+            created: Integer,
+            creator: String,
+            name: String,
+            providers: T::Hash[Symbol, Courier::MessageProvidersType],
+            routing: Courier::MessageRouting,
+            description: T.nilable(String),
+            tags: T.nilable(T::Array[String]),
+            updated: T.nilable(Integer),
+            updater: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_list_params.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyListParams < Courier::Internal::Type::BaseModel
+      extend Courier::Internal::Type::RequestParameters::Converter
+      include Courier::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Courier::RoutingStrategyListParams, Courier::Internal::AnyHash)
+        end
+
+      # Opaque pagination cursor from a previous response. Omit for the first page.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :cursor
+
+      # Maximum number of results per page. Default 20, max 100.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          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,
+        # Maximum number of results per page. Default 20, max 100.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            cursor: T.nilable(String),
+            limit: Integer,
+            request_options: Courier::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_list_response.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyListResponse < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::RoutingStrategyListResponse,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Courier::Paging) }
+      attr_reader :paging
+
+      sig { params(paging: Courier::Paging::OrHash).void }
+      attr_writer :paging
+
+      sig { returns(T::Array[Courier::RoutingStrategySummary]) }
+      attr_accessor :results
+
+      # Paginated list of routing strategy summaries.
+      sig do
+        params(
+          paging: Courier::Paging::OrHash,
+          results: T::Array[Courier::RoutingStrategySummary::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(paging:, results:)
+      end
+
+      sig do
+        override.returns(
+          {
+            paging: Courier::Paging,
+            results: T::Array[Courier::RoutingStrategySummary]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_mutation_response.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyMutationResponse < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::RoutingStrategyMutationResponse,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      # The routing strategy ID (rs\_ prefix).
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Response returned by create and replace operations.
+      sig { params(id: String).returns(T.attached_class) }
+      def self.new(
+        # The routing strategy ID (rs\_ prefix).
+        id:
+      )
+      end
+
+      sig { override.returns({ id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_replace_params.rbi

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

data/rbi/courier/models/routing_strategy_replace_request.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategyReplaceRequest < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::RoutingStrategyReplaceRequest,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      # Human-readable name for the routing strategy.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Routing tree defining channel selection method and order.
+      sig { returns(Courier::MessageRouting) }
+      attr_reader :routing
+
+      sig { params(routing: Courier::MessageRouting::OrHash).void }
+      attr_writer :routing
+
+      # Per-channel delivery configuration. Omit to clear.
+      sig { returns(T.nilable(T::Hash[Symbol, Courier::Channel])) }
+      attr_accessor :channels
+
+      # Optional description. Omit or null to clear.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # Per-provider delivery configuration. Omit to clear.
+      sig { returns(T.nilable(T::Hash[Symbol, Courier::MessageProvidersType])) }
+      attr_accessor :providers
+
+      # Optional tags. Omit or null to clear.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :tags
+
+      # Request body for replacing a routing strategy. Full document replacement;
+      # missing optional fields are cleared.
+      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])
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            routing: Courier::MessageRouting,
+            channels: T.nilable(T::Hash[Symbol, Courier::Channel]),
+            description: T.nilable(String),
+            providers:
+              T.nilable(T::Hash[Symbol, Courier::MessageProvidersType]),
+            tags: T.nilable(T::Array[String])
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/routing_strategy_retrieve_params.rbi

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