trycourier 4.7.1 → 4.9.0

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

data/rbi/courier/models/routing_strategy_summary.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Courier
+  module Models
+    class RoutingStrategySummary < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::RoutingStrategySummary, Courier::Internal::AnyHash)
+        end
+
+      # The routing strategy ID (rs\_ prefix).
+      sig { returns(String) }
+      attr_accessor :id
+
+      # 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
+
+      # 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
+
+      # Routing strategy metadata returned in list responses. Does not include
+      # routing/channels/providers content.
+      sig do
+        params(
+          id: String,
+          created: Integer,
+          creator: String,
+          name: String,
+          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:,
+        # Epoch milliseconds when the strategy was created.
+        created:,
+        # User ID of the creator.
+        creator:,
+        # Human-readable name.
+        name:,
+        # 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,
+            created: Integer,
+            creator: String,
+            name: String,
+            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