trycourier 4.10.1 → 4.11.0

data/rbi/courier/models/journey_create_params.rbi

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

@@ -0,0 +1,146 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyDelayDurationNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyDelayDurationNode, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :duration
+
+      sig { returns(Courier::JourneyDelayDurationNode::Mode::OrSymbol) }
+      attr_accessor :mode
+
+      sig { returns(Courier::JourneyDelayDurationNode::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
+
+      # Pause the journey run for a fixed `duration`.
+      sig do
+        params(
+          duration: String,
+          mode: Courier::JourneyDelayDurationNode::Mode::OrSymbol,
+          type: Courier::JourneyDelayDurationNode::Type::OrSymbol,
+          id: String,
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            )
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        duration:,
+        mode:,
+        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
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            duration: String,
+            mode: Courier::JourneyDelayDurationNode::Mode::OrSymbol,
+            type: Courier::JourneyDelayDurationNode::Type::OrSymbol,
+            id: String,
+            conditions:
+              T.any(
+                T::Array[String],
+                Courier::JourneyConditionGroup,
+                Courier::JourneyConditionNestedGroup
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Mode
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneyDelayDurationNode::Mode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DURATION =
+          T.let(
+            :duration,
+            Courier::JourneyDelayDurationNode::Mode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyDelayDurationNode::Mode::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneyDelayDurationNode::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DELAY =
+          T.let(:delay, Courier::JourneyDelayDurationNode::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyDelayDurationNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_delay_until_node.rbi

@@ -0,0 +1,139 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyDelayUntilNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyDelayUntilNode, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(Courier::JourneyDelayUntilNode::Mode::OrSymbol) }
+      attr_accessor :mode
+
+      sig { returns(Courier::JourneyDelayUntilNode::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(String) }
+      attr_accessor :until_
+
+      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
+
+      # Pause the journey run `until` a specific time.
+      sig do
+        params(
+          mode: Courier::JourneyDelayUntilNode::Mode::OrSymbol,
+          type: Courier::JourneyDelayUntilNode::Type::OrSymbol,
+          until_: String,
+          id: String,
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            )
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        mode:,
+        type:,
+        until_:,
+        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
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            mode: Courier::JourneyDelayUntilNode::Mode::OrSymbol,
+            type: Courier::JourneyDelayUntilNode::Type::OrSymbol,
+            until_: String,
+            id: String,
+            conditions:
+              T.any(
+                T::Array[String],
+                Courier::JourneyConditionGroup,
+                Courier::JourneyConditionNestedGroup
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Mode
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Courier::JourneyDelayUntilNode::Mode) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        UNTIL =
+          T.let(:until, Courier::JourneyDelayUntilNode::Mode::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyDelayUntilNode::Mode::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Courier::JourneyDelayUntilNode::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DELAY =
+          T.let(:delay, Courier::JourneyDelayUntilNode::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyDelayUntilNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_exit_node.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyExitNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyExitNode, Courier::Internal::AnyHash)
+        end
+
+      sig { returns(Courier::JourneyExitNode::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # Terminate the journey run.
+      sig do
+        params(
+          type: Courier::JourneyExitNode::Type::OrSymbol,
+          id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(type:, id: nil)
+      end
+
+      sig do
+        override.returns(
+          { type: Courier::JourneyExitNode::Type::OrSymbol, id: String }
+        )
+      end
+      def to_hash
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Courier::JourneyExitNode::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EXIT = T.let(:exit, Courier::JourneyExitNode::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyExitNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/journey_fetch_get_delete_node.rbi

@@ -0,0 +1,186 @@
+# typed: strong
+
+module Courier
+  module Models
+    class JourneyFetchGetDeleteNode < Courier::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Courier::JourneyFetchGetDeleteNode, Courier::Internal::AnyHash)
+        end
+
+      # Strategy for merging a fetch response into the journey run state.
+      sig { returns(Courier::JourneyMergeStrategy::OrSymbol) }
+      attr_accessor :merge_strategy
+
+      sig { returns(Courier::JourneyFetchGetDeleteNode::Method::OrSymbol) }
+      attr_accessor :method_
+
+      sig { returns(Courier::JourneyFetchGetDeleteNode::Type::OrSymbol) }
+      attr_accessor :type
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      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
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :headers
+
+      sig { params(headers: T::Hash[Symbol, String]).void }
+      attr_writer :headers
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :query_params
+
+      sig { params(query_params: T::Hash[Symbol, String]).void }
+      attr_writer :query_params
+
+      # A JSONSchema object (Draft-07-compatible). Validated at runtime by Ajv.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :response_schema
+
+      sig { params(response_schema: T::Hash[Symbol, T.anything]).void }
+      attr_writer :response_schema
+
+      # Issue an HTTP GET or DELETE request and merge the response into the journey
+      # state per `merge_strategy`.
+      sig do
+        params(
+          merge_strategy: Courier::JourneyMergeStrategy::OrSymbol,
+          method_: Courier::JourneyFetchGetDeleteNode::Method::OrSymbol,
+          type: Courier::JourneyFetchGetDeleteNode::Type::OrSymbol,
+          url: String,
+          id: String,
+          conditions:
+            T.any(
+              T::Array[String],
+              Courier::JourneyConditionGroup::OrHash,
+              Courier::JourneyConditionNestedGroup::OrHash
+            ),
+          headers: T::Hash[Symbol, String],
+          query_params: T::Hash[Symbol, String],
+          response_schema: T::Hash[Symbol, T.anything]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Strategy for merging a fetch response into the journey run state.
+        merge_strategy:,
+        method_:,
+        type:,
+        url:,
+        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,
+        headers: nil,
+        query_params: nil,
+        # A JSONSchema object (Draft-07-compatible). Validated at runtime by Ajv.
+        response_schema: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            merge_strategy: Courier::JourneyMergeStrategy::OrSymbol,
+            method_: Courier::JourneyFetchGetDeleteNode::Method::OrSymbol,
+            type: Courier::JourneyFetchGetDeleteNode::Type::OrSymbol,
+            url: String,
+            id: String,
+            conditions:
+              T.any(
+                T::Array[String],
+                Courier::JourneyConditionGroup,
+                Courier::JourneyConditionNestedGroup
+              ),
+            headers: T::Hash[Symbol, String],
+            query_params: T::Hash[Symbol, String],
+            response_schema: T::Hash[Symbol, T.anything]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Method
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneyFetchGetDeleteNode::Method)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        GET =
+          T.let(:get, Courier::JourneyFetchGetDeleteNode::Method::TaggedSymbol)
+        DELETE =
+          T.let(
+            :delete,
+            Courier::JourneyFetchGetDeleteNode::Method::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyFetchGetDeleteNode::Method::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Type
+        extend Courier::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Courier::JourneyFetchGetDeleteNode::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FETCH =
+          T.let(:fetch, Courier::JourneyFetchGetDeleteNode::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Courier::JourneyFetchGetDeleteNode::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end