knockapi 0.6.1 → 1.0.0

data/rbi/knockapi/models/message.rbi

@@ -0,0 +1,322 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class Message < Knockapi::Internal::Type::BaseModel
+      # The unique identifier for the message.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # The typename of the schema.
+      sig { returns(T.nilable(String)) }
+      attr_reader :_typename
+
+      sig { params(_typename: String).void }
+      attr_writer :_typename
+
+      # One or more actors that are associated with this message. Note: this is a list
+      # that can contain up to 10 actors if the message is produced from a
+      # [batch](/designing-workflows/batch-function).
+      sig { returns(T.nilable(T::Array[T.any(String, Knockapi::Models::RecipientReference::ObjectReference)])) }
+      attr_reader :actors
+
+      sig do
+        params(
+          actors: T::Array[T.any(String, Knockapi::Models::RecipientReference::ObjectReference, Knockapi::Internal::AnyHash)]
+        )
+          .void
+      end
+      attr_writer :actors
+
+      # Timestamp when the message was archived.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :archived_at
+
+      # The ID for the channel the message was sent through.
+      sig { returns(T.nilable(String)) }
+      attr_reader :channel_id
+
+      sig { params(channel_id: String).void }
+      attr_writer :channel_id
+
+      # Timestamp when the message was clicked.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :clicked_at
+
+      # Data associated with the message’s workflow run. Includes the workflow trigger
+      # request’s `data` payload merged with any additional data returned by a
+      # [fetch function](/designing-workflows/fetch-function). For messages produced
+      # after a [batch step](/designing-workflows/batch-function), includes the payload
+      # `data` from the most-recent trigger request (the final `activity` in the batch).
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      # A list of engagement statuses.
+      sig { returns(T.nilable(T::Array[Knockapi::Models::Message::EngagementStatus::TaggedSymbol])) }
+      attr_reader :engagement_statuses
+
+      sig { params(engagement_statuses: T::Array[Knockapi::Models::Message::EngagementStatus::OrSymbol]).void }
+      attr_writer :engagement_statuses
+
+      # Timestamp when the resource was created.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :inserted_at
+
+      sig { params(inserted_at: Time).void }
+      attr_writer :inserted_at
+
+      # Timestamp when the message was interacted with.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :interacted_at
+
+      # Timestamp when a link in the message was clicked.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :link_clicked_at
+
+      # The metadata associated with the message.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :metadata
+
+      # Timestamp when the message was read.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :read_at
+
+      # A reference to a recipient, either a user identifier (string) or an object
+      # reference (ID, collection).
+      sig { returns(T.nilable(T.any(String, Knockapi::Models::RecipientReference::ObjectReference))) }
+      attr_reader :recipient
+
+      sig do
+        params(
+          recipient: T.any(String, Knockapi::Models::RecipientReference::ObjectReference, Knockapi::Internal::AnyHash)
+        )
+          .void
+      end
+      attr_writer :recipient
+
+      # Timestamp when the message was scheduled to be sent.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :scheduled_at
+
+      # Timestamp when the message was seen.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :seen_at
+
+      # The workflow that triggered the message.
+      sig { returns(T.nilable(Knockapi::Models::Message::Source)) }
+      attr_reader :source
+
+      sig { params(source: T.any(Knockapi::Models::Message::Source, Knockapi::Internal::AnyHash)).void }
+      attr_writer :source
+
+      # The message delivery status.
+      sig { returns(T.nilable(Knockapi::Models::Message::Status::TaggedSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Knockapi::Models::Message::Status::OrSymbol).void }
+      attr_writer :status
+
+      # The ID of the `tenant` associated with the message. Only present when a `tenant`
+      # is provided on a workflow trigger request.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tenant
+
+      # The timestamp when the resource was last updated.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
+
+      # The key of the workflow that generated the message.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :workflow
+
+      # Represents a single message that was generated by a workflow for a given
+      # channel.
+      sig do
+        params(
+          id: String,
+          _typename: String,
+          actors: T::Array[T.any(String, Knockapi::Models::RecipientReference::ObjectReference, Knockapi::Internal::AnyHash)],
+          archived_at: T.nilable(Time),
+          channel_id: String,
+          clicked_at: T.nilable(Time),
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          engagement_statuses: T::Array[Knockapi::Models::Message::EngagementStatus::OrSymbol],
+          inserted_at: Time,
+          interacted_at: T.nilable(Time),
+          link_clicked_at: T.nilable(Time),
+          metadata: T.nilable(T::Hash[Symbol, T.anything]),
+          read_at: T.nilable(Time),
+          recipient: T.any(String, Knockapi::Models::RecipientReference::ObjectReference, Knockapi::Internal::AnyHash),
+          scheduled_at: T.nilable(Time),
+          seen_at: T.nilable(Time),
+          source: T.any(Knockapi::Models::Message::Source, Knockapi::Internal::AnyHash),
+          status: Knockapi::Models::Message::Status::OrSymbol,
+          tenant: T.nilable(String),
+          updated_at: Time,
+          workflow: T.nilable(String)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The unique identifier for the message.
+        id: nil,
+        # The typename of the schema.
+        _typename: nil,
+        # One or more actors that are associated with this message. Note: this is a list
+        # that can contain up to 10 actors if the message is produced from a
+        # [batch](/designing-workflows/batch-function).
+        actors: nil,
+        # Timestamp when the message was archived.
+        archived_at: nil,
+        # The ID for the channel the message was sent through.
+        channel_id: nil,
+        # Timestamp when the message was clicked.
+        clicked_at: nil,
+        # Data associated with the message’s workflow run. Includes the workflow trigger
+        # request’s `data` payload merged with any additional data returned by a
+        # [fetch function](/designing-workflows/fetch-function). For messages produced
+        # after a [batch step](/designing-workflows/batch-function), includes the payload
+        # `data` from the most-recent trigger request (the final `activity` in the batch).
+        data: nil,
+        # A list of engagement statuses.
+        engagement_statuses: nil,
+        # Timestamp when the resource was created.
+        inserted_at: nil,
+        # Timestamp when the message was interacted with.
+        interacted_at: nil,
+        # Timestamp when a link in the message was clicked.
+        link_clicked_at: nil,
+        # The metadata associated with the message.
+        metadata: nil,
+        # Timestamp when the message was read.
+        read_at: nil,
+        # A reference to a recipient, either a user identifier (string) or an object
+        # reference (ID, collection).
+        recipient: nil,
+        # Timestamp when the message was scheduled to be sent.
+        scheduled_at: nil,
+        # Timestamp when the message was seen.
+        seen_at: nil,
+        # The workflow that triggered the message.
+        source: nil,
+        # The message delivery status.
+        status: nil,
+        # The ID of the `tenant` associated with the message. Only present when a `tenant`
+        # is provided on a workflow trigger request.
+        tenant: nil,
+        # The timestamp when the resource was last updated.
+        updated_at: nil,
+        # The key of the workflow that generated the message.
+        workflow: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              id: String,
+              _typename: String,
+              actors: T::Array[T.any(String, Knockapi::Models::RecipientReference::ObjectReference)],
+              archived_at: T.nilable(Time),
+              channel_id: String,
+              clicked_at: T.nilable(Time),
+              data: T.nilable(T::Hash[Symbol, T.anything]),
+              engagement_statuses: T::Array[Knockapi::Models::Message::EngagementStatus::TaggedSymbol],
+              inserted_at: Time,
+              interacted_at: T.nilable(Time),
+              link_clicked_at: T.nilable(Time),
+              metadata: T.nilable(T::Hash[Symbol, T.anything]),
+              read_at: T.nilable(Time),
+              recipient: T.any(String, Knockapi::Models::RecipientReference::ObjectReference),
+              scheduled_at: T.nilable(Time),
+              seen_at: T.nilable(Time),
+              source: Knockapi::Models::Message::Source,
+              status: Knockapi::Models::Message::Status::TaggedSymbol,
+              tenant: T.nilable(String),
+              updated_at: Time,
+              workflow: T.nilable(String)
+            }
+          )
+      end
+      def to_hash; end
+
+      # An engagement status for a message. Can be one of: read, seen, interacted,
+      # link_clicked, archived.
+      module EngagementStatus
+        extend Knockapi::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Knockapi::Models::Message::EngagementStatus) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SEEN = T.let(:seen, Knockapi::Models::Message::EngagementStatus::TaggedSymbol)
+        READ = T.let(:read, Knockapi::Models::Message::EngagementStatus::TaggedSymbol)
+        INTERACTED = T.let(:interacted, Knockapi::Models::Message::EngagementStatus::TaggedSymbol)
+        LINK_CLICKED = T.let(:link_clicked, Knockapi::Models::Message::EngagementStatus::TaggedSymbol)
+        ARCHIVED = T.let(:archived, Knockapi::Models::Message::EngagementStatus::TaggedSymbol)
+
+        sig { override.returns(T::Array[Knockapi::Models::Message::EngagementStatus::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      class Source < Knockapi::Internal::Type::BaseModel
+        sig { returns(String) }
+        attr_accessor :_typename
+
+        # The categories associated with the message.
+        sig { returns(T::Array[String]) }
+        attr_accessor :categories
+
+        # The key of the workflow that triggered the message.
+        sig { returns(String) }
+        attr_accessor :key
+
+        # The ID of the version of the workflow that triggered the message.
+        sig { returns(String) }
+        attr_accessor :version_id
+
+        # The workflow that triggered the message.
+        sig do
+          params(_typename: String, categories: T::Array[String], key: String, version_id: String)
+            .returns(T.attached_class)
+        end
+        def self.new(
+          _typename:,
+          # The categories associated with the message.
+          categories:,
+          # The key of the workflow that triggered the message.
+          key:,
+          # The ID of the version of the workflow that triggered the message.
+          version_id:
+        ); end
+        sig do
+          override.returns({_typename: String, categories: T::Array[String], key: String, version_id: String})
+        end
+        def to_hash; end
+      end
+
+      # The message delivery status.
+      module Status
+        extend Knockapi::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Knockapi::Models::Message::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        QUEUED = T.let(:queued, Knockapi::Models::Message::Status::TaggedSymbol)
+        SENT = T.let(:sent, Knockapi::Models::Message::Status::TaggedSymbol)
+        DELIVERED = T.let(:delivered, Knockapi::Models::Message::Status::TaggedSymbol)
+        DELIVERY_ATTEMPTED = T.let(:delivery_attempted, Knockapi::Models::Message::Status::TaggedSymbol)
+        UNDELIVERED = T.let(:undelivered, Knockapi::Models::Message::Status::TaggedSymbol)
+        NOT_SENT = T.let(:not_sent, Knockapi::Models::Message::Status::TaggedSymbol)
+        BOUNCED = T.let(:bounced, Knockapi::Models::Message::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Knockapi::Models::Message::Status::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/knockapi/models/message_archive_params.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class MessageArchiveParams < Knockapi::Internal::Type::BaseModel
+      extend Knockapi::Internal::Type::RequestParameters::Converter
+      include Knockapi::Internal::Type::RequestParameters
+
+      sig do
+        params(request_options: T.any(Knockapi::RequestOptions, Knockapi::Internal::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {}); end
+
+      sig { override.returns({request_options: Knockapi::RequestOptions}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/knockapi/models/message_delivery_log.rbi

@@ -0,0 +1,260 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class MessageDeliveryLog < Knockapi::Internal::Type::BaseModel
+      # The unique identifier for the message delivery log.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The typename of the schema.
+      sig { returns(String) }
+      attr_accessor :_typename
+
+      # The ID of the environment in which the message delivery occurred.
+      sig { returns(String) }
+      attr_accessor :environment_id
+
+      # Timestamp when the message delivery log was created.
+      sig { returns(String) }
+      attr_accessor :inserted_at
+
+      # A message delivery log request.
+      sig { returns(Knockapi::Models::MessageDeliveryLog::Request) }
+      attr_reader :request
+
+      sig { params(request: T.any(Knockapi::Models::MessageDeliveryLog::Request, Knockapi::Internal::AnyHash)).void }
+      attr_writer :request
+
+      # A message delivery log response.
+      sig { returns(Knockapi::Models::MessageDeliveryLog::Response) }
+      attr_reader :response
+
+      sig { params(response: T.any(Knockapi::Models::MessageDeliveryLog::Response, Knockapi::Internal::AnyHash)).void }
+      attr_writer :response
+
+      # The name of the service that processed the delivery.
+      sig { returns(String) }
+      attr_accessor :service_name
+
+      # A message delivery log contains a `request` from Knock to a downstream provider
+      # and the `response` that was returned.
+      sig do
+        params(
+          id: String,
+          _typename: String,
+          environment_id: String,
+          inserted_at: String,
+          request: T.any(Knockapi::Models::MessageDeliveryLog::Request, Knockapi::Internal::AnyHash),
+          response: T.any(Knockapi::Models::MessageDeliveryLog::Response, Knockapi::Internal::AnyHash),
+          service_name: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The unique identifier for the message delivery log.
+        id:,
+        # The typename of the schema.
+        _typename:,
+        # The ID of the environment in which the message delivery occurred.
+        environment_id:,
+        # Timestamp when the message delivery log was created.
+        inserted_at:,
+        # A message delivery log request.
+        request:,
+        # A message delivery log response.
+        response:,
+        # The name of the service that processed the delivery.
+        service_name:
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              id: String,
+              _typename: String,
+              environment_id: String,
+              inserted_at: String,
+              request: Knockapi::Models::MessageDeliveryLog::Request,
+              response: Knockapi::Models::MessageDeliveryLog::Response,
+              service_name: String
+            }
+          )
+      end
+      def to_hash; end
+
+      class Request < Knockapi::Internal::Type::BaseModel
+        # The body content that was sent with the request.
+        sig { returns(T.nilable(T.any(String, T::Hash[Symbol, T.anything]))) }
+        attr_reader :body
+
+        sig { params(body: T.any(String, T::Hash[Symbol, T.anything])).void }
+        attr_writer :body
+
+        # The headers that were sent with the request.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :headers
+
+        # The host to which the request was sent.
+        sig { returns(T.nilable(String)) }
+        attr_reader :host
+
+        sig { params(host: String).void }
+        attr_writer :host
+
+        # The HTTP method used for the request.
+        sig { returns(T.nilable(Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol)) }
+        attr_reader :method_
+
+        sig { params(method_: Knockapi::Models::MessageDeliveryLog::Request::Method::OrSymbol).void }
+        attr_writer :method_
+
+        # The path of the URL that was requested.
+        sig { returns(T.nilable(String)) }
+        attr_reader :path
+
+        sig { params(path: String).void }
+        attr_writer :path
+
+        # The query string of the URL that was requested.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :query
+
+        # A message delivery log request.
+        sig do
+          params(
+            body: T.any(String, T::Hash[Symbol, T.anything]),
+            headers: T.nilable(T::Hash[Symbol, T.anything]),
+            host: String,
+            method_: Knockapi::Models::MessageDeliveryLog::Request::Method::OrSymbol,
+            path: String,
+            query: T.nilable(String)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The body content that was sent with the request.
+          body: nil,
+          # The headers that were sent with the request.
+          headers: nil,
+          # The host to which the request was sent.
+          host: nil,
+          # The HTTP method used for the request.
+          method_: nil,
+          # The path of the URL that was requested.
+          path: nil,
+          # The query string of the URL that was requested.
+          query: nil
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                body: T.any(String, T::Hash[Symbol, T.anything]),
+                headers: T.nilable(T::Hash[Symbol, T.anything]),
+                host: String,
+                method_: Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol,
+                path: String,
+                query: T.nilable(String)
+              }
+            )
+        end
+        def to_hash; end
+
+        # The body content that was sent with the request.
+        module Body
+          extend Knockapi::Internal::Type::Union
+
+          sig { override.returns([String, T::Hash[Symbol, T.anything]]) }
+          def self.variants; end
+
+          UnionMember1Map =
+            T.let(
+              Knockapi::Internal::Type::HashOf[Knockapi::Internal::Type::Unknown],
+              Knockapi::Internal::Type::Converter
+            )
+        end
+
+        # The HTTP method used for the request.
+        module Method
+          extend Knockapi::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Knockapi::Models::MessageDeliveryLog::Request::Method) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          GET = T.let(:GET, Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol)
+          POST = T.let(:POST, Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol)
+          PUT = T.let(:PUT, Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol)
+          DELETE = T.let(:DELETE, Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol)
+          PATCH = T.let(:PATCH, Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol)
+
+          sig { override.returns(T::Array[Knockapi::Models::MessageDeliveryLog::Request::Method::TaggedSymbol]) }
+          def self.values; end
+        end
+      end
+
+      class Response < Knockapi::Internal::Type::BaseModel
+        # The body content that was received with the response.
+        sig { returns(T.nilable(T.any(String, T::Hash[Symbol, T.anything]))) }
+        attr_reader :body
+
+        sig { params(body: T.any(String, T::Hash[Symbol, T.anything])).void }
+        attr_writer :body
+
+        # The headers that were received with the response.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :headers
+
+        # The HTTP status code of the response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :status
+
+        sig { params(status: Integer).void }
+        attr_writer :status
+
+        # A message delivery log response.
+        sig do
+          params(
+            body: T.any(String, T::Hash[Symbol, T.anything]),
+            headers: T.nilable(T::Hash[Symbol, T.anything]),
+            status: Integer
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The body content that was received with the response.
+          body: nil,
+          # The headers that were received with the response.
+          headers: nil,
+          # The HTTP status code of the response.
+          status: nil
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                body: T.any(String, T::Hash[Symbol, T.anything]),
+                headers: T.nilable(T::Hash[Symbol, T.anything]),
+                status: Integer
+              }
+            )
+        end
+        def to_hash; end
+
+        # The body content that was received with the response.
+        module Body
+          extend Knockapi::Internal::Type::Union
+
+          sig { override.returns([String, T::Hash[Symbol, T.anything]]) }
+          def self.variants; end
+
+          UnionMember1Map =
+            T.let(
+              Knockapi::Internal::Type::HashOf[Knockapi::Internal::Type::Unknown],
+              Knockapi::Internal::Type::Converter
+            )
+        end
+      end
+    end
+  end
+end

data/rbi/knockapi/models/message_event.rbi

@@ -0,0 +1,103 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class MessageEvent < Knockapi::Internal::Type::BaseModel
+      # The unique identifier for the message event.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The typename of the schema.
+      sig { returns(String) }
+      attr_accessor :_typename
+
+      # Timestamp when the event was created.
+      sig { returns(Time) }
+      attr_accessor :inserted_at
+
+      # A reference to a recipient, either a user identifier (string) or an object
+      # reference (ID, collection).
+      sig { returns(T.any(String, Knockapi::Models::RecipientReference::ObjectReference)) }
+      attr_accessor :recipient
+
+      # The type of event that occurred.
+      sig { returns(Knockapi::Models::MessageEvent::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # The data associated with the message event. Only present for some event types.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      # A message event. Occurs when a message
+      # [delivery or engagement status](/send-notifications/message-statuses) changes.
+      sig do
+        params(
+          id: String,
+          _typename: String,
+          inserted_at: Time,
+          recipient: T.any(String, Knockapi::Models::RecipientReference::ObjectReference, Knockapi::Internal::AnyHash),
+          type: Knockapi::Models::MessageEvent::Type::OrSymbol,
+          data: T.nilable(T::Hash[Symbol, T.anything])
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The unique identifier for the message event.
+        id:,
+        # The typename of the schema.
+        _typename:,
+        # Timestamp when the event was created.
+        inserted_at:,
+        # A reference to a recipient, either a user identifier (string) or an object
+        # reference (ID, collection).
+        recipient:,
+        # The type of event that occurred.
+        type:,
+        # The data associated with the message event. Only present for some event types.
+        data: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              id: String,
+              _typename: String,
+              inserted_at: Time,
+              recipient: T.any(String, Knockapi::Models::RecipientReference::ObjectReference),
+              type: Knockapi::Models::MessageEvent::Type::TaggedSymbol,
+              data: T.nilable(T::Hash[Symbol, T.anything])
+            }
+          )
+      end
+      def to_hash; end
+
+      # The type of event that occurred.
+      module Type
+        extend Knockapi::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Knockapi::Models::MessageEvent::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MESSAGE_ARCHIVED = T.let(:"message.archived", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_BOUNCED = T.let(:"message.bounced", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_DELIVERED = T.let(:"message.delivered", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_DELIVERY_ATTEMPTED =
+          T.let(:"message.delivery_attempted", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_INTERACTED = T.let(:"message.interacted", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_LINK_CLICKED = T.let(:"message.link_clicked", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_NOT_SENT = T.let(:"message.not_sent", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_QUEUED = T.let(:"message.queued", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_READ = T.let(:"message.read", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_SEEN = T.let(:"message.seen", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_SENT = T.let(:"message.sent", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_UNARCHIVED = T.let(:"message.unarchived", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_UNDELIVERED = T.let(:"message.undelivered", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_UNREAD = T.let(:"message.unread", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+        MESSAGE_UNSEEN = T.let(:"message.unseen", Knockapi::Models::MessageEvent::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Knockapi::Models::MessageEvent::Type::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end