svix 1.76.1 → 1.77.0

data/lib/svix/models/connector_kind.rb

@@ -3,6 +3,7 @@
 module Svix
   class ConnectorKind
     CUSTOM = "Custom".freeze
+    AGENTIC_COMMERCE_PROTOCOL = "AgenticCommerceProtocol".freeze
     CLOSE_CRM = "CloseCRM".freeze
     CUSTOMER_IO = "CustomerIO".freeze
     DISCORD = "Discord".freeze
@@ -22,6 +23,7 @@ module Svix
     def self.all_vars
       @all_vars ||= [
         CUSTOM,
+        AGENTIC_COMMERCE_PROTOCOL,
         CLOSE_CRM,
         CUSTOMER_IO,
         DISCORD,

data/lib/svix/models/connector_out.rb

@@ -6,13 +6,11 @@ module Svix
   class ConnectorOut
     attr_accessor :created_at
     attr_accessor :description
-    attr_accessor :feature_flag
     attr_accessor :feature_flags
     attr_accessor :filter_types
     # The Connector's ID.
     attr_accessor :id
     attr_accessor :instructions
-    attr_accessor :instructions_link
     attr_accessor :kind
     attr_accessor :logo
     attr_accessor :name
@@ -24,12 +22,10 @@ module Svix
     ALL_FIELD ||= [
       "created_at",
       "description",
-      "feature_flag",
       "feature_flags",
       "filter_types",
       "id",
       "instructions",
-      "instructions_link",
       "kind",
       "logo",
       "name",
@@ -59,12 +55,10 @@ module Svix
       attrs = Hash.new
       attrs["created_at"] = DateTime.rfc3339(attributes["createdAt"]).to_time
       attrs["description"] = attributes["description"]
-      attrs["feature_flag"] = attributes["featureFlag"]
       attrs["feature_flags"] = attributes["featureFlags"]
       attrs["filter_types"] = attributes["filterTypes"]
       attrs["id"] = attributes["id"]
       attrs["instructions"] = attributes["instructions"]
-      attrs["instructions_link"] = attributes["instructionsLink"]
       attrs["kind"] = Svix::ConnectorKind.deserialize(attributes["kind"])
       attrs["logo"] = attributes["logo"]
       attrs["name"] = attributes["name"]
@@ -78,12 +72,10 @@ module Svix
       out = Hash.new
       out["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
       out["description"] = Svix::serialize_primitive(@description) if @description
-      out["featureFlag"] = Svix::serialize_primitive(@feature_flag) if @feature_flag
       out["featureFlags"] = Svix::serialize_primitive(@feature_flags) if @feature_flags
       out["filterTypes"] = Svix::serialize_primitive(@filter_types) if @filter_types
       out["id"] = Svix::serialize_primitive(@id) if @id
       out["instructions"] = Svix::serialize_primitive(@instructions) if @instructions
-      out["instructionsLink"] = Svix::serialize_primitive(@instructions_link) if @instructions_link
       out["kind"] = Svix::serialize_schema_ref(@kind) if @kind
       out["logo"] = Svix::serialize_primitive(@logo) if @logo
       out["name"] = Svix::serialize_primitive(@name) if @name

data/lib/svix/models/create_stream_events_in.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class CreateStreamEventsIn
+    attr_accessor :events
+    # Optionally creates a new Stream alongside the events.
+    #
+    # If the stream id or uid that is used in the path already exists, this argument is ignored.
+    attr_accessor :stream
+
+    ALL_FIELD ||= ["events", "stream"].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::CreateStreamEventsIn` 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::CreateStreamEventsIn")
+        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["events"] = attributes["events"].map { |v| Svix::EventIn.deserialize(v) }
+      attrs["stream"] = Svix::StreamIn.deserialize(attributes["stream"]) if attributes["stream"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["events"] = @events.map { |v| v.serialize } if @events
+      out["stream"] = Svix::serialize_schema_ref(@stream) if @stream
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/create_stream_events_out.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class CreateStreamEventsOut
+
+    ALL_FIELD ||= [].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::CreateStreamEventsOut` 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::CreateStreamEventsOut")
+        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
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/empty_response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class EmptyResponse
+
+    ALL_FIELD ||= [].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::EmptyResponse` 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::EmptyResponse")
+        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
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/endpoint_message_out.rb

@@ -7,6 +7,7 @@ module Svix
   class EndpointMessageOut
     # 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
@@ -22,6 +23,7 @@ module Svix
 
     ALL_FIELD ||= [
       "channels",
+      "deliver_at",
       "event_id",
       "event_type",
       "id",
@@ -53,6 +55,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"]
@@ -68,6 +71,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

data/lib/svix/models/event_in.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class EventIn
+    # The event type's name
+    attr_accessor :event_type
+    attr_accessor :payload
+
+    ALL_FIELD ||= ["event_type", "payload"].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::EventIn` 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::EventIn")
+        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["event_type"] = attributes["eventType"]
+      attrs["payload"] = attributes["payload"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["eventType"] = Svix::serialize_primitive(@event_type) if @event_type
+      out["payload"] = Svix::serialize_primitive(@payload) if @payload
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/event_out.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class EventOut
+    # The event type's name
+    attr_accessor :event_type
+    attr_accessor :payload
+    attr_accessor :timestamp
+
+    ALL_FIELD ||= ["event_type", "payload", "timestamp"].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::EventOut` 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::EventOut")
+        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["event_type"] = attributes["eventType"]
+      attrs["payload"] = attributes["payload"]
+      attrs["timestamp"] = DateTime.rfc3339(attributes["timestamp"]).to_time
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["eventType"] = Svix::serialize_primitive(@event_type) if @event_type
+      out["payload"] = Svix::serialize_primitive(@payload) if @payload
+      out["timestamp"] = Svix::serialize_primitive(@timestamp) if @timestamp
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/event_stream_out.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class EventStreamOut
+    attr_accessor :data
+    attr_accessor :done
+    attr_accessor :iterator
+
+    ALL_FIELD ||= ["data", "done", "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::EventStreamOut` 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::EventStreamOut")
+        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::EventOut.deserialize(v) }
+      attrs["done"] = attributes["done"]
+      attrs["iterator"] = attributes["iterator"]
+      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
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/google_cloud_storage_config.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Configuration for a Google Cloud Storage sink.
+  #
+  # Write stream events into the named bucket using the supplied Google Cloud credentials.
+  class GoogleCloudStorageConfig
+    attr_accessor :bucket
+    # Google Cloud Credentials JSON Object as a string.
+    attr_accessor :credentials
+
+    ALL_FIELD ||= ["bucket", "credentials"].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::GoogleCloudStorageConfig` 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::GoogleCloudStorageConfig")
+        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["bucket"] = attributes["bucket"]
+      attrs["credentials"] = attributes["credentials"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["bucket"] = Svix::serialize_primitive(@bucket) if @bucket
+      out["credentials"] = Svix::serialize_primitive(@credentials) if @credentials
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/google_cloud_storage_patch_config.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class GoogleCloudStoragePatchConfig
+    attr_accessor :bucket
+    attr_accessor :credentials
+
+    ALL_FIELD ||= ["bucket", "credentials"].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::GoogleCloudStoragePatchConfig` 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::GoogleCloudStoragePatchConfig")
+        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["bucket"] = attributes["bucket"]
+      attrs["credentials"] = attributes["credentials"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["bucket"] = Svix::serialize_primitive(@bucket) if @bucket
+      out["credentials"] = Svix::serialize_primitive(@credentials) if @credentials
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/http_patch_config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class HttpPatchConfig
+    attr_accessor :url
+
+    ALL_FIELD ||= ["url"].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::HttpPatchConfig` 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::HttpPatchConfig")
+        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["url"] = attributes["url"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["url"] = Svix::serialize_primitive(@url) if @url
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/http_sink_headers_patch_in.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class HttpSinkHeadersPatchIn
+    attr_accessor :headers
+
+    ALL_FIELD ||= ["headers"].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::HttpSinkHeadersPatchIn` 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::HttpSinkHeadersPatchIn")
+        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["headers"] = attributes["headers"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["headers"] = Svix::serialize_primitive(@headers) if @headers
+      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_endpoint_disabled_event.rb

@@ -0,0 +1,53 @@
+# 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 IngestEndpointDisabledEvent
+    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::IngestEndpointDisabledEvent` 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::IngestEndpointDisabledEvent")
+        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::IngestEndpointDisabledEventData.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