trycourier 6.9.0 → 6.11.0

data/rbi/courier/models/notifications/previews/create_preview_run_request.rbi

@@ -0,0 +1,110 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      module Previews
+        class CreatePreviewRunRequest < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::Notifications::Previews::CreatePreviewRunRequest,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          # Template variables to render with, the same shape as the `data` object on a
+          # send.
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_reader :data
+
+          sig { params(data: T::Hash[Symbol, T.anything]).void }
+          attr_writer :data
+
+          # The devices to render on, by `PreviewDevice.id`, for a one-off run. Mutually
+          # exclusive with `device_set_id`.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :device_ids
+
+          sig { params(device_ids: T::Array[String]).void }
+          attr_writer :device_ids
+
+          # A saved device set naming the devices to render on. Mutually exclusive with
+          # `device_ids`.
+          sig { returns(T.nilable(String)) }
+          attr_reader :device_set_id
+
+          sig { params(device_set_id: String).void }
+          attr_writer :device_set_id
+
+          # Render the template's content for this locale, e.g. "fr-FR".
+          sig { returns(T.nilable(String)) }
+          attr_reader :locale
+
+          sig { params(locale: String).void }
+          attr_writer :locale
+
+          # Which version of the template to render. Omit for the latest saved draft, which
+          # always exists and is what the editor shows. `published` renders the live
+          # version; a zero-padded `v002` renders that specific publish. Versions are
+          # 1-based, so `v000` is not a version, and the unpadded `v2` is rejected — that
+          # spelling belongs to journeys' AutomationVersionId, a different scheme in which
+          # `v0` means published.
+          sig { returns(T.nilable(String)) }
+          attr_reader :template_version
+
+          sig { params(template_version: String).void }
+          attr_writer :template_version
+
+          # Request body for creating a preview run of the template in the path. Provide
+          # exactly one of `device_set_id` or `device_ids`. The template is the path's
+          # `{id}`; a `template_id` here is an unknown key and a 400.
+          sig do
+            params(
+              data: T::Hash[Symbol, T.anything],
+              device_ids: T::Array[String],
+              device_set_id: String,
+              locale: String,
+              template_version: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Template variables to render with, the same shape as the `data` object on a
+            # send.
+            data: nil,
+            # The devices to render on, by `PreviewDevice.id`, for a one-off run. Mutually
+            # exclusive with `device_set_id`.
+            device_ids: nil,
+            # A saved device set naming the devices to render on. Mutually exclusive with
+            # `device_ids`.
+            device_set_id: nil,
+            # Render the template's content for this locale, e.g. "fr-FR".
+            locale: nil,
+            # Which version of the template to render. Omit for the latest saved draft, which
+            # always exists and is what the editor shows. `published` renders the live
+            # version; a zero-padded `v002` renders that specific publish. Versions are
+            # 1-based, so `v000` is not a version, and the unpadded `v2` is rejected — that
+            # spelling belongs to journeys' AutomationVersionId, a different scheme in which
+            # `v0` means published.
+            template_version: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                data: T::Hash[Symbol, T.anything],
+                device_ids: T::Array[String],
+                device_set_id: String,
+                locale: String,
+                template_version: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notifications/previews/preview_result.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      PreviewResult = Previews::PreviewResult
+
+      module Previews
+        class PreviewResult < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::Notifications::Previews::PreviewResult,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          # The device this result is for, by `PreviewDevice.id`.
+          sig { returns(String) }
+          attr_accessor :device_id
+
+          # Short-lived signed URL for the full-sized image. Null until the screenshot
+          # exists. Re-signed on every read, so fetch it rather than storing it.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :screenshot_url
+
+          # One device's outcome. `COMPLETED` means the screenshot exists and its URLs are
+          # populated. `UNSUPPORTED`, `TIMED_OUT` and `FAILED` are all terminal, and none
+          # stands in for another — `UNSUPPORTED` means the device was retired at the
+          # vendor, `TIMED_OUT` means it did not report in time.
+          sig do
+            returns(
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          # Short-lived signed URL for the grid-sized image. Null until the screenshot
+          # exists. Re-signed on every read, so fetch it rather than storing it.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :thumbnail_url
+
+          # Why one device's render failed, when its `status` is `FAILED` and the cause has
+          # a public name. `DELIVERY_FAILED` means the rendering service could not deliver
+          # the message to its own capture mailbox — infrastructure, not anything wrong with
+          # the template.
+          sig do
+            returns(
+              T.nilable(
+                Courier::Notifications::Previews::PreviewResultFailureReason::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :failure_reason
+
+          sig do
+            params(
+              failure_reason:
+                Courier::Notifications::Previews::PreviewResultFailureReason::OrSymbol
+            ).void
+          end
+          attr_writer :failure_reason
+
+          # One device's result within a preview run.
+          sig do
+            params(
+              device_id: String,
+              screenshot_url: T.nilable(String),
+              status:
+                Courier::Notifications::Previews::PreviewResultStatus::OrSymbol,
+              thumbnail_url: T.nilable(String),
+              failure_reason:
+                Courier::Notifications::Previews::PreviewResultFailureReason::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The device this result is for, by `PreviewDevice.id`.
+            device_id:,
+            # Short-lived signed URL for the full-sized image. Null until the screenshot
+            # exists. Re-signed on every read, so fetch it rather than storing it.
+            screenshot_url:,
+            # One device's outcome. `COMPLETED` means the screenshot exists and its URLs are
+            # populated. `UNSUPPORTED`, `TIMED_OUT` and `FAILED` are all terminal, and none
+            # stands in for another — `UNSUPPORTED` means the device was retired at the
+            # vendor, `TIMED_OUT` means it did not report in time.
+            status:,
+            # Short-lived signed URL for the grid-sized image. Null until the screenshot
+            # exists. Re-signed on every read, so fetch it rather than storing it.
+            thumbnail_url:,
+            # Why one device's render failed, when its `status` is `FAILED` and the cause has
+            # a public name. `DELIVERY_FAILED` means the rendering service could not deliver
+            # the message to its own capture mailbox — infrastructure, not anything wrong with
+            # the template.
+            failure_reason: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                device_id: String,
+                screenshot_url: T.nilable(String),
+                status:
+                  Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol,
+                thumbnail_url: T.nilable(String),
+                failure_reason:
+                  Courier::Notifications::Previews::PreviewResultFailureReason::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notifications/previews/preview_result_failure_reason.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      PreviewResultFailureReason = Previews::PreviewResultFailureReason
+
+      module Previews
+        # Why one device's render failed, when its `status` is `FAILED` and the cause has
+        # a public name. `DELIVERY_FAILED` means the rendering service could not deliver
+        # the message to its own capture mailbox — infrastructure, not anything wrong with
+        # the template.
+        module PreviewResultFailureReason
+          extend Courier::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Courier::Notifications::Previews::PreviewResultFailureReason
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DELIVERY_FAILED =
+            T.let(
+              :DELIVERY_FAILED,
+              Courier::Notifications::Previews::PreviewResultFailureReason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Courier::Notifications::Previews::PreviewResultFailureReason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notifications/previews/preview_result_status.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      PreviewResultStatus = Previews::PreviewResultStatus
+
+      module Previews
+        # One device's outcome. `COMPLETED` means the screenshot exists and its URLs are
+        # populated. `UNSUPPORTED`, `TIMED_OUT` and `FAILED` are all terminal, and none
+        # stands in for another — `UNSUPPORTED` means the device was retired at the
+        # vendor, `TIMED_OUT` means it did not report in time.
+        module PreviewResultStatus
+          extend Courier::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Courier::Notifications::Previews::PreviewResultStatus
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PENDING =
+            T.let(
+              :PENDING,
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+          PROCESSING =
+            T.let(
+              :PROCESSING,
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+          COMPLETED =
+            T.let(
+              :COMPLETED,
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+          UNSUPPORTED =
+            T.let(
+              :UNSUPPORTED,
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+          TIMED_OUT =
+            T.let(
+              :TIMED_OUT,
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+          FAILED =
+            T.let(
+              :FAILED,
+              Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Courier::Notifications::Previews::PreviewResultStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notifications/previews/preview_run.rbi

@@ -0,0 +1,134 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      PreviewRun = Previews::PreviewRun
+
+      module Previews
+        class PreviewRun < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::Notifications::Previews::PreviewRun,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          # Unique identifier for the preview run.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # ISO-8601 timestamp of when the run was created.
+          sig { returns(String) }
+          attr_accessor :created_at
+
+          # The devices this run was submitted for, snapshotted when the run was created.
+          sig { returns(T::Array[String]) }
+          attr_accessor :device_ids
+
+          # Where the run itself has got to. `PENDING` and `RENDERED` mean Courier is still
+          # preparing the email, `SUBMITTED` means it is with the rendering service, and
+          # `COMPLETED` means every device has reported. `FAILED` is the run as a whole
+          # failing — an individual device failing never fails the run.
+          sig do
+            returns(
+              Courier::Notifications::Previews::PreviewRunStatus::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          # The template that was rendered.
+          sig { returns(String) }
+          attr_accessor :template_id
+
+          # Why the run failed, when `status` is `FAILED`. `NO_EMAIL_CHANNEL` and
+          # `TEMPLATE_NOT_SUPPORTED` mean there was nothing to render;
+          # `ALL_DEVICES_UNSUPPORTED` means every requested device has been retired and the
+          # request can be fixed by choosing others.
+          sig do
+            returns(
+              T.nilable(
+                Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :failure_reason
+
+          sig do
+            params(
+              failure_reason:
+                Courier::Notifications::Previews::PreviewRunFailureReason::OrSymbol
+            ).void
+          end
+          attr_writer :failure_reason
+
+          # The version of the template that was rendered — `draft`, or a zero-padded
+          # published version such as `v002`. Absent until the render settles.
+          sig { returns(T.nilable(String)) }
+          attr_reader :template_version
+
+          sig { params(template_version: String).void }
+          attr_writer :template_version
+
+          # One render of a template across a set of devices. Billable.
+          sig do
+            params(
+              id: String,
+              created_at: String,
+              device_ids: T::Array[String],
+              status:
+                Courier::Notifications::Previews::PreviewRunStatus::OrSymbol,
+              template_id: String,
+              failure_reason:
+                Courier::Notifications::Previews::PreviewRunFailureReason::OrSymbol,
+              template_version: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Unique identifier for the preview run.
+            id:,
+            # ISO-8601 timestamp of when the run was created.
+            created_at:,
+            # The devices this run was submitted for, snapshotted when the run was created.
+            device_ids:,
+            # Where the run itself has got to. `PENDING` and `RENDERED` mean Courier is still
+            # preparing the email, `SUBMITTED` means it is with the rendering service, and
+            # `COMPLETED` means every device has reported. `FAILED` is the run as a whole
+            # failing — an individual device failing never fails the run.
+            status:,
+            # The template that was rendered.
+            template_id:,
+            # Why the run failed, when `status` is `FAILED`. `NO_EMAIL_CHANNEL` and
+            # `TEMPLATE_NOT_SUPPORTED` mean there was nothing to render;
+            # `ALL_DEVICES_UNSUPPORTED` means every requested device has been retired and the
+            # request can be fixed by choosing others.
+            failure_reason: nil,
+            # The version of the template that was rendered — `draft`, or a zero-padded
+            # published version such as `v002`. Absent until the render settles.
+            template_version: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                created_at: String,
+                device_ids: T::Array[String],
+                status:
+                  Courier::Notifications::Previews::PreviewRunStatus::TaggedSymbol,
+                template_id: String,
+                failure_reason:
+                  Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol,
+                template_version: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notifications/previews/preview_run_detail.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      PreviewRunDetail = Previews::PreviewRunDetail
+
+      module Previews
+        class PreviewRunDetail < Courier::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Courier::Notifications::Previews::PreviewRunDetail,
+                Courier::Internal::AnyHash
+              )
+            end
+
+          # Unique identifier for the preview run.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # ISO-8601 timestamp of when the run was created.
+          sig { returns(String) }
+          attr_accessor :created_at
+
+          # The devices this run was submitted for, snapshotted when the run was created.
+          sig { returns(T::Array[String]) }
+          attr_accessor :device_ids
+
+          # One entry per device in `device_ids`.
+          sig do
+            returns(T::Array[Courier::Notifications::Previews::PreviewResult])
+          end
+          attr_accessor :results
+
+          # Where the run itself has got to. `PENDING` and `RENDERED` mean Courier is still
+          # preparing the email, `SUBMITTED` means it is with the rendering service, and
+          # `COMPLETED` means every device has reported. `FAILED` is the run as a whole
+          # failing — an individual device failing never fails the run.
+          sig do
+            returns(
+              Courier::Notifications::Previews::PreviewRunStatus::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          # The template that was rendered.
+          sig { returns(String) }
+          attr_accessor :template_id
+
+          # Why the run failed, when `status` is `FAILED`. `NO_EMAIL_CHANNEL` and
+          # `TEMPLATE_NOT_SUPPORTED` mean there was nothing to render;
+          # `ALL_DEVICES_UNSUPPORTED` means every requested device has been retired and the
+          # request can be fixed by choosing others.
+          sig do
+            returns(
+              T.nilable(
+                Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :failure_reason
+
+          sig do
+            params(
+              failure_reason:
+                Courier::Notifications::Previews::PreviewRunFailureReason::OrSymbol
+            ).void
+          end
+          attr_writer :failure_reason
+
+          # The version of the template that was rendered — `draft`, or a zero-padded
+          # published version such as `v002`. Absent until the render settles.
+          sig { returns(T.nilable(String)) }
+          attr_reader :template_version
+
+          sig { params(template_version: String).void }
+          attr_writer :template_version
+
+          # A preview run together with its per-device results.
+          sig do
+            params(
+              id: String,
+              created_at: String,
+              device_ids: T::Array[String],
+              results:
+                T::Array[
+                  Courier::Notifications::Previews::PreviewResult::OrHash
+                ],
+              status:
+                Courier::Notifications::Previews::PreviewRunStatus::OrSymbol,
+              template_id: String,
+              failure_reason:
+                Courier::Notifications::Previews::PreviewRunFailureReason::OrSymbol,
+              template_version: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Unique identifier for the preview run.
+            id:,
+            # ISO-8601 timestamp of when the run was created.
+            created_at:,
+            # The devices this run was submitted for, snapshotted when the run was created.
+            device_ids:,
+            # One entry per device in `device_ids`.
+            results:,
+            # Where the run itself has got to. `PENDING` and `RENDERED` mean Courier is still
+            # preparing the email, `SUBMITTED` means it is with the rendering service, and
+            # `COMPLETED` means every device has reported. `FAILED` is the run as a whole
+            # failing — an individual device failing never fails the run.
+            status:,
+            # The template that was rendered.
+            template_id:,
+            # Why the run failed, when `status` is `FAILED`. `NO_EMAIL_CHANNEL` and
+            # `TEMPLATE_NOT_SUPPORTED` mean there was nothing to render;
+            # `ALL_DEVICES_UNSUPPORTED` means every requested device has been retired and the
+            # request can be fixed by choosing others.
+            failure_reason: nil,
+            # The version of the template that was rendered — `draft`, or a zero-padded
+            # published version such as `v002`. Absent until the render settles.
+            template_version: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                created_at: String,
+                device_ids: T::Array[String],
+                results:
+                  T::Array[Courier::Notifications::Previews::PreviewResult],
+                status:
+                  Courier::Notifications::Previews::PreviewRunStatus::TaggedSymbol,
+                template_id: String,
+                failure_reason:
+                  Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol,
+                template_version: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/courier/models/notifications/previews/preview_run_failure_reason.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Courier
+  module Models
+    module Notifications
+      PreviewRunFailureReason = Previews::PreviewRunFailureReason
+
+      module Previews
+        # Why the run failed, when `status` is `FAILED`. `NO_EMAIL_CHANNEL` and
+        # `TEMPLATE_NOT_SUPPORTED` mean there was nothing to render;
+        # `ALL_DEVICES_UNSUPPORTED` means every requested device has been retired and the
+        # request can be fixed by choosing others.
+        module PreviewRunFailureReason
+          extend Courier::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Courier::Notifications::Previews::PreviewRunFailureReason
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TEMPLATE_NOT_SUPPORTED =
+            T.let(
+              :TEMPLATE_NOT_SUPPORTED,
+              Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+            )
+          NO_EMAIL_CHANNEL =
+            T.let(
+              :NO_EMAIL_CHANNEL,
+              Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+            )
+          RENDER_FAILED =
+            T.let(
+              :RENDER_FAILED,
+              Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+            )
+          ALL_DEVICES_UNSUPPORTED =
+            T.let(
+              :ALL_DEVICES_UNSUPPORTED,
+              Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+            )
+          VENDOR_ERROR =
+            T.let(
+              :VENDOR_ERROR,
+              Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Courier::Notifications::Previews::PreviewRunFailureReason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end