trycourier 6.0.0 → 6.2.0

data/rbi/courier/models/journey_run_step.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyRunStep < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyRunStep, Courier::Internal::AnyHash)
+        end
+
+      # The kind of node that ran, e.g. `send`, `delay`, or `exit`.
+      sig { returns(String) }
+      attr_accessor :action
+
+      # The state of the step: the seven run statuses, plus `SKIPPED` and `COMPUTING`.
+      # Not an enum — new values have been added before.
+      sig { returns(String) }
+      attr_accessor :status
+
+      # When the step started, as an ISO 8601 timestamp.
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_at
+
+      sig { params(created_at: String).void }
+      attr_writer :created_at
+
+      # The message this step produced, present on send steps. Pass it to
+      # `GET /messages/{message_id}` for delivery status. A send to a List or an
+      # Audience yields one id for the request, not one per recipient.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message_id
+
+      sig { params(message_id: String).void }
+      attr_writer :message_id
+
+      # The id of the node in the published Journey that this step executed.
+      sig { returns(T.nilable(String)) }
+      attr_reader :node_id
+
+      sig { params(node_id: String).void }
+      attr_writer :node_id
+
+      # When the step last changed state, as an ISO 8601 timestamp.
+      sig { returns(T.nilable(String)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: String).void }
+      attr_writer :updated_at
+
+      # One executed node of a Journey run. `node_id` is the id of the node in the
+      # published Journey, so a step maps directly onto the Journey graph.
+      sig do
+        params(
+          action: String,
+          status: String,
+          created_at: String,
+          message_id: String,
+          node_id: String,
+          updated_at: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The kind of node that ran, e.g. `send`, `delay`, or `exit`.
+        action:,
+        # The state of the step: the seven run statuses, plus `SKIPPED` and `COMPUTING`.
+        # Not an enum — new values have been added before.
+        status:,
+        # When the step started, as an ISO 8601 timestamp.
+        created_at: nil,
+        # The message this step produced, present on send steps. Pass it to
+        # `GET /messages/{message_id}` for delivery status. A send to a List or an
+        # Audience yields one id for the request, not one per recipient.
+        message_id: nil,
+        # The id of the node in the published Journey that this step executed.
+        node_id: nil,
+        # When the step last changed state, as an ISO 8601 timestamp.
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            action: String,
+            status: String,
+            created_at: String,
+            message_id: String,
+            node_id: String,
+            updated_at: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_run_steps_response.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyRunStepsResponse < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyRunStepsResponse, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[Courier::JourneyRunStep]) }
+      attr_accessor :steps
+
+      # Every step of a Journey run. Not paginated.
+      sig do
+        params(steps: T::Array[Courier::JourneyRunStep::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(steps:)
+      end
+
+      sig { override.returns({ steps: T::Array[Courier::JourneyRunStep] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_segment_trigger_node.rbi

@@ -57,7 +57,10 @@ module Courier
       sig { params(event_id: String).void }
       attr_writer :event_id
 
-      # Trigger fired by a segment event (`identify`, `group`, or `track`).
+      # Trigger fired by a segment event (`identify`, `group`, `track`, or `page`). A
+      # trigger with no `event_id` fires on any event of its type — the only shape
+      # `identify` and `group` can take, and the one that catches a stock
+      # `analytics.page()` call.
       sig do
         params(
           request_type:
@@ -134,6 +137,11 @@ module Courier
             :track,
             Courier::JourneySegmentTriggerNode::RequestType::TaggedSymbol
           )
+        PAGE =
+          T.let(
+            :page,
+            Courier::JourneySegmentTriggerNode::RequestType::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/courier/models/journey_webhook_trigger_node.rbi

@@ -0,0 +1,174 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyWebhookTriggerNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyWebhookTriggerNode, Courier::Internal::AnyHash)
+        end
+
+      # The provider key the webhook URL is minted for. Required, and must not contain a
+      # forward slash.
+      sig { returns(String) }
+      attr_accessor :event_source
+
+      sig { returns(Courier::JourneyWebhookTriggerNode::TriggerType::OrSymbol) }
+      attr_accessor :trigger_type
+
+      sig { returns(Courier::JourneyWebhookTriggerNode::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+      # group, or an AND/OR nested group. Omit the `conditions` property entirely to
+      # express "no conditions".
+      sig do
+        returns(
+          T.nilable(
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup,
+              Courier::JourneyConditionNestedGroup
+            )
+          )
+        )
+      end
+      attr_reader :conditions
+
+      sig do
+        params(
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            )
+        ).void
+      end
+      attr_writer :conditions
+
+      # An optional event filter, matched against the payload's `event` field. A sender
+      # that supplies no `event` matches the literal `custom`. Must not contain a
+      # forward slash. Omit to accept every event delivered to the URL.
+      sig { returns(T.nilable(String)) }
+      attr_reader :event_id
+
+      sig { params(event_id: String).void }
+      attr_writer :event_id
+
+      # Trigger fired when an external system POSTs to the webhook URL minted for
+      # `event_source`. Narrow it to one event with `event_id`, or omit `event_id` to
+      # accept every event delivered to the URL.
+      sig do
+        params(
+          event_source: String,
+          trigger_type:
+            Courier::JourneyWebhookTriggerNode::TriggerType::OrSymbol,
+          type: Courier::JourneyWebhookTriggerNode::Type::OrSymbol,
+          id: String,
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            ),
+          event_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The provider key the webhook URL is minted for. Required, and must not contain a
+        # forward slash.
+        event_source:,
+        trigger_type:,
+        type:,
+        id: nil,
+        # Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+        # group, or an AND/OR nested group. Omit the `conditions` property entirely to
+        # express "no conditions".
+        conditions: nil,
+        # An optional event filter, matched against the payload's `event` field. A sender
+        # that supplies no `event` matches the literal `custom`. Must not contain a
+        # forward slash. Omit to accept every event delivered to the URL.
+        event_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            event_source: String,
+            trigger_type:
+              Courier::JourneyWebhookTriggerNode::TriggerType::OrSymbol,
+            type: Courier::JourneyWebhookTriggerNode::Type::OrSymbol,
+            id: String,
+            conditions:
+              T.any(
+                T::Array[String],
+                Courier::JourneyConditionGroup,
+                Courier::JourneyConditionNestedGroup
+              ),
+            event_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module TriggerType
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneyWebhookTriggerNode::TriggerType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        WEBHOOK =
+          T.let(
+            :webhook,
+            Courier::JourneyWebhookTriggerNode::TriggerType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Courier::JourneyWebhookTriggerNode::TriggerType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneyWebhookTriggerNode::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRIGGER =
+          T.let(
+            :trigger,
+            Courier::JourneyWebhookTriggerNode::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyWebhookTriggerNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journeys/run_list_params.rbi

@@ -0,0 +1,111 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Journeys
+      class RunListParams < Courier::Internal::Type::BaseModel
+        extend Courier::Internal::Type::RequestParameters::Converter
+        include Courier::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Courier::Journeys::RunListParams, Courier::Internal::AnyHash)
+          end
+
+        # A cursor token for pagination. Use the `next_cursor` from the previous response
+        # to fetch the next page of results. Treat it as opaque.
+        sig { returns(T.nilable(String)) }
+        attr_reader :cursor
+
+        sig { params(cursor: String).void }
+        attr_writer :cursor
+
+        # An inclusive upper bound on `created_at`, in the same format as `start_date`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :end_date
+
+        sig { params(end_date: String).void }
+        attr_writer :end_date
+
+        # The number of runs to return per page, between `1` and `50`. Defaults to `20`.
+        # Values outside the range are clamped, and a non-numeric value falls back to
+        # `20`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :limit
+
+        sig { params(limit: String).void }
+        attr_writer :limit
+
+        # An inclusive lower bound on `created_at`, as an ISO 8601 date or timestamp (e.g.
+        # `2026-08-18` or `2026-08-18T20:06:36.259Z`). Any other format returns `400`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :start_date
+
+        sig { params(start_date: String).void }
+        attr_writer :start_date
+
+        # A comma-separated list of run statuses to filter on, e.g. `PROCESSED,ERROR`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :status
+
+        sig { params(status: String).void }
+        attr_writer :status
+
+        # A comma-separated list of Journey ids to filter on.
+        sig { returns(T.nilable(String)) }
+        attr_reader :template_id
+
+        sig { params(template_id: String).void }
+        attr_writer :template_id
+
+        sig do
+          params(
+            cursor: String,
+            end_date: String,
+            limit: String,
+            start_date: String,
+            status: String,
+            template_id: String,
+            request_options: Courier::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A cursor token for pagination. Use the `next_cursor` from the previous response
+          # to fetch the next page of results. Treat it as opaque.
+          cursor: nil,
+          # An inclusive upper bound on `created_at`, in the same format as `start_date`.
+          end_date: nil,
+          # The number of runs to return per page, between `1` and `50`. Defaults to `20`.
+          # Values outside the range are clamped, and a non-numeric value falls back to
+          # `20`.
+          limit: nil,
+          # An inclusive lower bound on `created_at`, as an ISO 8601 date or timestamp (e.g.
+          # `2026-08-18` or `2026-08-18T20:06:36.259Z`). Any other format returns `400`.
+          start_date: nil,
+          # A comma-separated list of run statuses to filter on, e.g. `PROCESSED,ERROR`.
+          status: nil,
+          # A comma-separated list of Journey ids to filter on.
+          template_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              cursor: String,
+              end_date: String,
+              limit: String,
+              start_date: String,
+              status: String,
+              template_id: String,
+              request_options: Courier::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journeys/run_list_steps_params.rbi

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

data/rbi/courier/models/journeys/run_retrieve_params.rbi

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

data/rbi/courier/models/notification_get_metrics_params.rbi

@@ -0,0 +1,167 @@
+# typed: strong
+
+module Courier
+  module Models
+    class NotificationGetMetricsParams < Courier::Internal::Type::BaseModel
+      extend Courier::Internal::Type::RequestParameters::Converter
+      include Courier::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Courier::NotificationGetMetricsParams,
+            Courier::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The end of the window, as an ISO 8601 timestamp with an offset. Must be supplied
+      # together with `start`. An `end` in the future is accepted and not clamped — the
+      # trailing buckets come back empty.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :end_
+
+      sig { params(end_: Time).void }
+      attr_writer :end_
+
+      # The size of each bucket in the series. Defaults to `DAY`. `WEEK` buckets start
+      # on Sunday. A fine granularity caps the window it can cover: `HOUR` spans at most
+      # 7 days and `DAY` at most 90 days, and a wider window returns `400` — request a
+      # coarser granularity instead. `WEEK` and `MONTH` are uncapped, subject to the
+      # 1000-bucket limit on a single response.
+      sig do
+        returns(
+          T.nilable(
+            Courier::NotificationGetMetricsParams::Granularity::OrSymbol
+          )
+        )
+      end
+      attr_reader :granularity
+
+      sig do
+        params(
+          granularity:
+            Courier::NotificationGetMetricsParams::Granularity::OrSymbol
+        ).void
+      end
+      attr_writer :granularity
+
+      # The length of the window, counted back from now, as an ISO 8601 duration
+      # (`P30D`, `P12W`, `PT12H`). Defaults to `P30D`, and is ignored when `start` and
+      # `end` are supplied. A malformed or non-positive duration returns `400`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :lookback
+
+      sig { params(lookback: String).void }
+      attr_writer :lookback
+
+      # The inclusive start of the window, as an ISO 8601 timestamp with an offset
+      # (`2026-04-01T00:00:00Z`). Must be supplied together with `end` and be earlier
+      # than it; either one alone returns `400`.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :start
+
+      sig { params(start: Time).void }
+      attr_writer :start
+
+      sig do
+        params(
+          id: String,
+          end_: Time,
+          granularity:
+            Courier::NotificationGetMetricsParams::Granularity::OrSymbol,
+          lookback: String,
+          start: Time,
+          request_options: Courier::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # The end of the window, as an ISO 8601 timestamp with an offset. Must be supplied
+        # together with `start`. An `end` in the future is accepted and not clamped — the
+        # trailing buckets come back empty.
+        end_: nil,
+        # The size of each bucket in the series. Defaults to `DAY`. `WEEK` buckets start
+        # on Sunday. A fine granularity caps the window it can cover: `HOUR` spans at most
+        # 7 days and `DAY` at most 90 days, and a wider window returns `400` — request a
+        # coarser granularity instead. `WEEK` and `MONTH` are uncapped, subject to the
+        # 1000-bucket limit on a single response.
+        granularity: nil,
+        # The length of the window, counted back from now, as an ISO 8601 duration
+        # (`P30D`, `P12W`, `PT12H`). Defaults to `P30D`, and is ignored when `start` and
+        # `end` are supplied. A malformed or non-positive duration returns `400`.
+        lookback: nil,
+        # The inclusive start of the window, as an ISO 8601 timestamp with an offset
+        # (`2026-04-01T00:00:00Z`). Must be supplied together with `end` and be earlier
+        # than it; either one alone returns `400`.
+        start: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            end_: Time,
+            granularity:
+              Courier::NotificationGetMetricsParams::Granularity::OrSymbol,
+            lookback: String,
+            start: Time,
+            request_options: Courier::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The size of each bucket in the series. Defaults to `DAY`. `WEEK` buckets start
+      # on Sunday. A fine granularity caps the window it can cover: `HOUR` spans at most
+      # 7 days and `DAY` at most 90 days, and a wider window returns `400` — request a
+      # coarser granularity instead. `WEEK` and `MONTH` are uncapped, subject to the
+      # 1000-bucket limit on a single response.
+      module Granularity
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::NotificationGetMetricsParams::Granularity)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HOUR =
+          T.let(
+            :HOUR,
+            Courier::NotificationGetMetricsParams::Granularity::TaggedSymbol
+          )
+        DAY =
+          T.let(
+            :DAY,
+            Courier::NotificationGetMetricsParams::Granularity::TaggedSymbol
+          )
+        WEEK =
+          T.let(
+            :WEEK,
+            Courier::NotificationGetMetricsParams::Granularity::TaggedSymbol
+          )
+        MONTH =
+          T.let(
+            :MONTH,
+            Courier::NotificationGetMetricsParams::Granularity::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Courier::NotificationGetMetricsParams::Granularity::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end