svix 1.76.0 → 1.77.0

data/lib/svix/models/ingest_endpoint_disabled_event_data.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent when an ingest endpoint has been automatically disabled after continuous failures, or manually via an API call.
+  class IngestEndpointDisabledEventData
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    # The Endpoint's UID.
+    attr_accessor :endpoint_uid
+    attr_accessor :fail_since
+    # The Source's ID.
+    attr_accessor :source_id
+    attr_accessor :trigger
+
+    ALL_FIELD ||= ["endpoint_id", "endpoint_uid", "fail_since", "source_id", "trigger"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestEndpointDisabledEventData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestEndpointDisabledEventData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["endpoint_uid"] = attributes["endpointUid"]
+      attrs["fail_since"] = DateTime.rfc3339(attributes["failSince"]).to_time if attributes["failSince"]
+      attrs["source_id"] = attributes["sourceId"]
+      attrs["trigger"] = Svix::EndpointDisabledTrigger.deserialize(attributes["trigger"]) if attributes["trigger"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["endpointId"] = Svix::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["endpointUid"] = Svix::serialize_primitive(@endpoint_uid) if @endpoint_uid
+      out["failSince"] = Svix::serialize_primitive(@fail_since) if @fail_since
+      out["sourceId"] = Svix::serialize_primitive(@source_id) if @source_id
+      out["trigger"] = Svix::serialize_schema_ref(@trigger) if @trigger
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_message_attempt_exhausted_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted).
+  class IngestMessageAttemptExhaustedEvent
+    attr_accessor :data
+    attr_accessor :type
+
+    ALL_FIELD ||= ["data", "type"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestMessageAttemptExhaustedEvent` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestMessageAttemptExhaustedEvent")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = Svix::IngestMessageAttemptExhaustedEventData.deserialize(attributes["data"])
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = Svix::serialize_schema_ref(@data) if @data
+      out["type"] = Svix::serialize_primitive(@type) if @type
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_message_attempt_exhausted_event_data.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted) as a "ingest.message.attempt.exhausted" type, after it's failed four times as a "ingest.message.attempt.failing" event, or after it's recovered as a "ingest.message.attempt.recovered" event.
+  class IngestMessageAttemptExhaustedEventData
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    attr_accessor :last_attempt
+    # The Message's UID.
+    attr_accessor :msg_event_id
+    # The Message's ID.
+    attr_accessor :msg_id
+    # The Source's ID.
+    attr_accessor :source_id
+
+    ALL_FIELD ||= ["endpoint_id", "last_attempt", "msg_event_id", "msg_id", "source_id"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestMessageAttemptExhaustedEventData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestMessageAttemptExhaustedEventData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["last_attempt"] = Svix::MessageAttemptFailedData.deserialize(attributes["lastAttempt"])
+      attrs["msg_event_id"] = attributes["msgEventId"]
+      attrs["msg_id"] = attributes["msgId"]
+      attrs["source_id"] = attributes["sourceId"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["endpointId"] = Svix::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["lastAttempt"] = Svix::serialize_schema_ref(@last_attempt) if @last_attempt
+      out["msgEventId"] = Svix::serialize_primitive(@msg_event_id) if @msg_event_id
+      out["msgId"] = Svix::serialize_primitive(@msg_id) if @msg_id
+      out["sourceId"] = Svix::serialize_primitive(@source_id) if @source_id
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_message_attempt_failing_event.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent after a message has been failing for a few times.
+  # It's sent on the fourth failure. It complements `ingest.message.attempt.exhausted` which is sent after the last failure.
+  class IngestMessageAttemptFailingEvent
+    attr_accessor :data
+    attr_accessor :type
+
+    ALL_FIELD ||= ["data", "type"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestMessageAttemptFailingEvent` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestMessageAttemptFailingEvent")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = Svix::IngestMessageAttemptFailingEventData.deserialize(attributes["data"])
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = Svix::serialize_schema_ref(@data) if @data
+      out["type"] = Svix::serialize_primitive(@type) if @type
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_message_attempt_failing_event_data.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted) as a "ingest.message.attempt.exhausted" type, after it's failed four times as a "ingest.message.attempt.failing" event, or after it's recovered as a "ingest.message.attempt.recovered" event.
+  class IngestMessageAttemptFailingEventData
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    attr_accessor :last_attempt
+    # The Message's UID.
+    attr_accessor :msg_event_id
+    # The Message's ID.
+    attr_accessor :msg_id
+    # The Source's ID.
+    attr_accessor :source_id
+
+    ALL_FIELD ||= ["endpoint_id", "last_attempt", "msg_event_id", "msg_id", "source_id"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestMessageAttemptFailingEventData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestMessageAttemptFailingEventData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["last_attempt"] = Svix::MessageAttemptFailedData.deserialize(attributes["lastAttempt"])
+      attrs["msg_event_id"] = attributes["msgEventId"]
+      attrs["msg_id"] = attributes["msgId"]
+      attrs["source_id"] = attributes["sourceId"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["endpointId"] = Svix::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["lastAttempt"] = Svix::serialize_schema_ref(@last_attempt) if @last_attempt
+      out["msgEventId"] = Svix::serialize_primitive(@msg_event_id) if @msg_event_id
+      out["msgId"] = Svix::serialize_primitive(@msg_id) if @msg_id
+      out["sourceId"] = Svix::serialize_primitive(@source_id) if @source_id
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_message_attempt_recovered_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent on a successful dispatch after an earlier failure op webhook has already been sent.
+  class IngestMessageAttemptRecoveredEvent
+    attr_accessor :data
+    attr_accessor :type
+
+    ALL_FIELD ||= ["data", "type"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestMessageAttemptRecoveredEvent` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestMessageAttemptRecoveredEvent")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = Svix::IngestMessageAttemptRecoveredEventData.deserialize(attributes["data"])
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = Svix::serialize_schema_ref(@data) if @data
+      out["type"] = Svix::serialize_primitive(@type) if @type
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_message_attempt_recovered_event_data.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted) as a "ingest.message.attempt.exhausted" type, after it's failed four times as a "ingest.message.attempt.failing" event, or after it's recovered as a "ingest.message.attempt.recovered" event.
+  class IngestMessageAttemptRecoveredEventData
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    attr_accessor :last_attempt
+    # The Message's UID.
+    attr_accessor :msg_event_id
+    # The Message's ID.
+    attr_accessor :msg_id
+    # The Source's ID.
+    attr_accessor :source_id
+
+    ALL_FIELD ||= ["endpoint_id", "last_attempt", "msg_event_id", "msg_id", "source_id"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::IngestMessageAttemptRecoveredEventData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::IngestMessageAttemptRecoveredEventData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["last_attempt"] = Svix::MessageAttemptFailedData.deserialize(attributes["lastAttempt"])
+      attrs["msg_event_id"] = attributes["msgEventId"]
+      attrs["msg_id"] = attributes["msgId"]
+      attrs["source_id"] = attributes["sourceId"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["endpointId"] = Svix::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["lastAttempt"] = Svix::serialize_schema_ref(@last_attempt) if @last_attempt
+      out["msgEventId"] = Svix::serialize_primitive(@msg_event_id) if @msg_event_id
+      out["msgId"] = Svix::serialize_primitive(@msg_id) if @msg_id
+      out["sourceId"] = Svix::serialize_primitive(@source_id) if @source_id
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/list_response_stream_event_type_out.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class ListResponseStreamEventTypeOut
+    attr_accessor :data
+    attr_accessor :done
+    attr_accessor :iterator
+    attr_accessor :prev_iterator
+
+    ALL_FIELD ||= ["data", "done", "iterator", "prev_iterator"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::ListResponseStreamEventTypeOut` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::ListResponseStreamEventTypeOut")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = attributes["data"].map { |v| Svix::StreamEventTypeOut.deserialize(v) }
+      attrs["done"] = attributes["done"]
+      attrs["iterator"] = attributes["iterator"]
+      attrs["prev_iterator"] = attributes["prevIterator"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = @data.map { |v| v.serialize } if @data
+      out["done"] = Svix::serialize_primitive(@done) if @done
+      out["iterator"] = Svix::serialize_primitive(@iterator) if @iterator
+      out["prevIterator"] = Svix::serialize_primitive(@prev_iterator) if @prev_iterator
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/list_response_stream_out.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class ListResponseStreamOut
+    attr_accessor :data
+    attr_accessor :done
+    attr_accessor :iterator
+    attr_accessor :prev_iterator
+
+    ALL_FIELD ||= ["data", "done", "iterator", "prev_iterator"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::ListResponseStreamOut` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::ListResponseStreamOut")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = attributes["data"].map { |v| Svix::StreamOut.deserialize(v) }
+      attrs["done"] = attributes["done"]
+      attrs["iterator"] = attributes["iterator"]
+      attrs["prev_iterator"] = attributes["prevIterator"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = @data.map { |v| v.serialize } if @data
+      out["done"] = Svix::serialize_primitive(@done) if @done
+      out["iterator"] = Svix::serialize_primitive(@iterator) if @iterator
+      out["prevIterator"] = Svix::serialize_primitive(@prev_iterator) if @prev_iterator
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/list_response_stream_sink_out.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class ListResponseStreamSinkOut
+    attr_accessor :data
+    attr_accessor :done
+    attr_accessor :iterator
+    attr_accessor :prev_iterator
+
+    ALL_FIELD ||= ["data", "done", "iterator", "prev_iterator"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::ListResponseStreamSinkOut` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::ListResponseStreamSinkOut")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = attributes["data"].map { |v| Svix::StreamSinkOut.deserialize(v) }
+      attrs["done"] = attributes["done"]
+      attrs["iterator"] = attributes["iterator"]
+      attrs["prev_iterator"] = attributes["prevIterator"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = @data.map { |v| v.serialize } if @data
+      out["done"] = Svix::serialize_primitive(@done) if @done
+      out["iterator"] = Svix::serialize_primitive(@iterator) if @iterator
+      out["prevIterator"] = Svix::serialize_primitive(@prev_iterator) if @prev_iterator
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/message_in.rb

@@ -10,6 +10,10 @@ module Svix
     attr_accessor :application
     # List of free-form identifiers that endpoints can filter by
     attr_accessor :channels
+    # The date and time at which the message will be delivered.
+    #
+    # Note that this time is best-effort-only. Must be at least one minute and no more than 24 hours in the future.
+    attr_accessor :deliver_at
     # Optional unique identifier for the message
     attr_accessor :event_id
     # The event type's name
@@ -30,6 +34,7 @@ module Svix
     ALL_FIELD ||= [
       "application",
       "channels",
+      "deliver_at",
       "event_id",
       "event_type",
       "payload",
@@ -60,6 +65,7 @@ module Svix
       attrs = Hash.new
       attrs["application"] = Svix::ApplicationIn.deserialize(attributes["application"]) if attributes["application"]
       attrs["channels"] = attributes["channels"]
+      attrs["deliver_at"] = DateTime.rfc3339(attributes["deliverAt"]).to_time if attributes["deliverAt"]
       attrs["event_id"] = attributes["eventId"]
       attrs["event_type"] = attributes["eventType"]
       attrs["payload"] = attributes["payload"]
@@ -74,6 +80,7 @@ module Svix
       out = Hash.new
       out["application"] = Svix::serialize_schema_ref(@application) if @application
       out["channels"] = Svix::serialize_primitive(@channels) if @channels
+      out["deliverAt"] = Svix::serialize_primitive(@deliver_at) if @deliver_at
       out["eventId"] = Svix::serialize_primitive(@event_id) if @event_id
       out["eventType"] = Svix::serialize_primitive(@event_type) if @event_type
       out["payload"] = Svix::serialize_primitive(@payload) if @payload

data/lib/svix/models/message_out.rb

@@ -6,6 +6,7 @@ module Svix
   class MessageOut
     # List of free-form identifiers that endpoints can filter by
     attr_accessor :channels
+    attr_accessor :deliver_at
     # Optional unique identifier for the message
     attr_accessor :event_id
     # The event type's name
@@ -16,7 +17,7 @@ module Svix
     attr_accessor :tags
     attr_accessor :timestamp
 
-    ALL_FIELD ||= ["channels", "event_id", "event_type", "id", "payload", "tags", "timestamp"].freeze
+    ALL_FIELD ||= ["channels", "deliver_at", "event_id", "event_type", "id", "payload", "tags", "timestamp"].freeze
     private_constant :ALL_FIELD
 
     def initialize(attributes = {})
@@ -38,6 +39,7 @@ module Svix
       attributes = attributes.transform_keys(&:to_s)
       attrs = Hash.new
       attrs["channels"] = attributes["channels"]
+      attrs["deliver_at"] = DateTime.rfc3339(attributes["deliverAt"]).to_time if attributes["deliverAt"]
       attrs["event_id"] = attributes["eventId"]
       attrs["event_type"] = attributes["eventType"]
       attrs["id"] = attributes["id"]
@@ -50,6 +52,7 @@ module Svix
     def serialize
       out = Hash.new
       out["channels"] = Svix::serialize_primitive(@channels) if @channels
+      out["deliverAt"] = Svix::serialize_primitive(@deliver_at) if @deliver_at
       out["eventId"] = Svix::serialize_primitive(@event_id) if @event_id
       out["eventType"] = Svix::serialize_primitive(@event_type) if @event_type
       out["id"] = Svix::serialize_primitive(@id) if @id