svix 1.76.1 → 1.77.0

data/lib/svix/models/otel_tracing_patch_config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class OtelTracingPatchConfig
+    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::OtelTracingPatchConfig` 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::OtelTracingPatchConfig")
+        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/polling_endpoint_message_out.rb

@@ -7,6 +7,7 @@ module Svix
   class PollingEndpointMessageOut
     # 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
@@ -18,7 +19,7 @@ module Svix
     attr_accessor :tags
     attr_accessor :timestamp
 
-    ALL_FIELD ||= ["channels", "event_id", "event_type", "headers", "id", "payload", "tags", "timestamp"].freeze
+    ALL_FIELD ||= ["channels", "deliver_at", "event_id", "event_type", "headers", "id", "payload", "tags", "timestamp"].freeze
     private_constant :ALL_FIELD
 
     def initialize(attributes = {})
@@ -43,6 +44,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["headers"] = attributes["headers"]
@@ -56,6 +58,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["headers"] = Svix::serialize_primitive(@headers) if @headers

data/lib/svix/models/rotate_poller_token_in.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class RotatePollerTokenIn
+    # How long the token will be valid for, in seconds. Can be up to 31,536,000 seconds (1 year).
+    attr_accessor :expiry
+    # Updates the previous token's expiration, in seconds.
+    #
+    # If set to 0, the old token will immediately be revoked. Must be between 0 and 86,400 seconds (1 day).
+    #
+    # Defaults to 300 seconds (5 minutes).
+    attr_accessor :old_token_expiry
+
+    ALL_FIELD ||= ["expiry", "old_token_expiry"].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::RotatePollerTokenIn` 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::RotatePollerTokenIn")
+        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["expiry"] = attributes["expiry"]
+      attrs["old_token_expiry"] = attributes["oldTokenExpiry"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["expiry"] = Svix::serialize_primitive(@expiry) if @expiry
+      out["oldTokenExpiry"] = Svix::serialize_primitive(@old_token_expiry) if @old_token_expiry
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/s3_config.rb

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

data/lib/svix/models/sink_http_config.rb

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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class SinkSecretOut
+    # The endpoint's verification secret.
+    #
+    # Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+    # It is recommended to not set this and let the server generate the secret.
+    attr_accessor :key
+
+    ALL_FIELD ||= ["key"].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::SinkSecretOut` 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::SinkSecretOut")
+        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["key"] = attributes["key"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["key"] = Svix::serialize_primitive(@key) if @key
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/sink_status.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# This file is @generated
+module Svix
+  class SinkStatus
+    ENABLED = "enabled".freeze
+    PAUSED = "paused".freeze
+    DISABLED = "disabled".freeze
+    RETRYING = "retrying".freeze
+
+    def self.all_vars
+      @all_vars ||= [ENABLED, PAUSED, DISABLED, RETRYING].freeze
+    end
+
+    def initialize(value)
+      unless SinkStatus.all_vars.include?(value)
+        raise "Invalid ENUM value '#{value}' for class #SinkStatus"
+      end
+
+      @value = value
+    end
+
+    def self.deserialize(value)
+      return value if SinkStatus.all_vars.include?(value)
+      raise "Invalid ENUM value '#{value}' for class #SinkStatus"
+    end
+
+    def serialize
+      @value
+    end
+  end
+end

data/lib/svix/models/sink_status_in.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# This file is @generated
+module Svix
+  class SinkStatusIn
+    ENABLED = "enabled".freeze
+    DISABLED = "disabled".freeze
+
+    def self.all_vars
+      @all_vars ||= [ENABLED, DISABLED].freeze
+    end
+
+    def initialize(value)
+      unless SinkStatusIn.all_vars.include?(value)
+        raise "Invalid ENUM value '#{value}' for class #SinkStatusIn"
+      end
+
+      @value = value
+    end
+
+    def self.deserialize(value)
+      return value if SinkStatusIn.all_vars.include?(value)
+      raise "Invalid ENUM value '#{value}' for class #SinkStatusIn"
+    end
+
+    def serialize
+      @value
+    end
+  end
+end

data/lib/svix/models/sink_transform_in.rb

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

data/lib/svix/models/sink_transformation_out.rb

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

data/lib/svix/models/stream_event_type_in.rb

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

data/lib/svix/models/stream_event_type_out.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class StreamEventTypeOut
+    attr_accessor :archived
+    attr_accessor :created_at
+    attr_accessor :deprecated
+    attr_accessor :description
+    attr_accessor :feature_flags
+    # The event type's name
+    attr_accessor :name
+    attr_accessor :updated_at
+
+    ALL_FIELD ||= ["archived", "created_at", "deprecated", "description", "feature_flags", "name", "updated_at"].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::StreamEventTypeOut` 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::StreamEventTypeOut")
+        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["archived"] = attributes["archived"]
+      attrs["created_at"] = DateTime.rfc3339(attributes["createdAt"]).to_time
+      attrs["deprecated"] = attributes["deprecated"]
+      attrs["description"] = attributes["description"]
+      attrs["feature_flags"] = attributes["featureFlags"]
+      attrs["name"] = attributes["name"]
+      attrs["updated_at"] = DateTime.rfc3339(attributes["updatedAt"]).to_time
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["archived"] = Svix::serialize_primitive(@archived) if @archived
+      out["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
+      out["deprecated"] = Svix::serialize_primitive(@deprecated) if @deprecated
+      out["description"] = Svix::serialize_primitive(@description) if @description
+      out["featureFlags"] = Svix::serialize_primitive(@feature_flags) if @feature_flags
+      out["name"] = Svix::serialize_primitive(@name) if @name
+      out["updatedAt"] = Svix::serialize_primitive(@updated_at) if @updated_at
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/stream_event_type_patch.rb

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